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

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

@@ -1,183 +0,0 @@
-import { URIComponent } from "fast-uri";
-import type { CodeGen, Code, Name, ScopeValueSets, ValueScopeName } from "../compile/codegen";
-import type { SchemaEnv, SchemaCxt, SchemaObjCxt } from "../compile";
-import type { JSONType } from "../compile/rules";
-import type { KeywordCxt } from "../compile/validate";
-import type Ajv from "../core";
-interface _SchemaObject {
-    id?: string;
-    $id?: string;
-    $schema?: string;
-    [x: string]: any;
-}
-export interface SchemaObject extends _SchemaObject {
-    id?: string;
-    $id?: string;
-    $schema?: string;
-    $async?: false;
-    [x: string]: any;
-}
-export interface AsyncSchema extends _SchemaObject {
-    $async: true;
-}
-export type AnySchemaObject = SchemaObject | AsyncSchema;
-export type Schema = SchemaObject | boolean;
-export type AnySchema = Schema | AsyncSchema;
-export type SchemaMap = {
-    [Key in string]?: AnySchema;
-};
-export interface SourceCode {
-    validateName: ValueScopeName;
-    validateCode: string;
-    scopeValues: ScopeValueSets;
-    evaluated?: Code;
-}
-export interface DataValidationCxt<T extends string | number = string | number> {
-    instancePath: string;
-    parentData: {
-        [K in T]: any;
-    };
-    parentDataProperty: T;
-    rootData: Record<string, any> | any[];
-    dynamicAnchors: {
-        [Ref in string]?: ValidateFunction;
-    };
-}
-export interface ValidateFunction<T = unknown> {
-    (this: Ajv | any, data: any, dataCxt?: DataValidationCxt): data is T;
-    errors?: null | ErrorObject[];
-    evaluated?: Evaluated;
-    schema: AnySchema;
-    schemaEnv: SchemaEnv;
-    source?: SourceCode;
-}
-export interface JTDParser<T = unknown> {
-    (json: string): T | undefined;
-    message?: string;
-    position?: number;
-}
-export type EvaluatedProperties = {
-    [K in string]?: true;
-} | true;
-export type EvaluatedItems = number | true;
-export interface Evaluated {
-    props?: EvaluatedProperties;
-    items?: EvaluatedItems;
-    dynamicProps: boolean;
-    dynamicItems: boolean;
-}
-export interface AsyncValidateFunction<T = unknown> extends ValidateFunction<T> {
-    (...args: Parameters<ValidateFunction<T>>): Promise<T>;
-    $async: true;
-}
-export type AnyValidateFunction<T = any> = ValidateFunction<T> | AsyncValidateFunction<T>;
-export interface ErrorObject<K extends string = string, P = Record<string, any>, S = unknown> {
-    keyword: K;
-    instancePath: string;
-    schemaPath: string;
-    params: P;
-    propertyName?: string;
-    message?: string;
-    schema?: S;
-    parentSchema?: AnySchemaObject;
-    data?: unknown;
-}
-export type ErrorNoParams<K extends string, S = unknown> = ErrorObject<K, Record<string, never>, S>;
-interface _KeywordDef {
-    keyword: string | string[];
-    type?: JSONType | JSONType[];
-    schemaType?: JSONType | JSONType[];
-    allowUndefined?: boolean;
-    $data?: boolean;
-    implements?: string[];
-    before?: string;
-    post?: boolean;
-    metaSchema?: AnySchemaObject;
-    validateSchema?: AnyValidateFunction;
-    dependencies?: string[];
-    error?: KeywordErrorDefinition;
-    $dataError?: KeywordErrorDefinition;
-}
-export interface CodeKeywordDefinition extends _KeywordDef {
-    code: (cxt: KeywordCxt, ruleType?: string) => void;
-    trackErrors?: boolean;
-}
-export type MacroKeywordFunc = (schema: any, parentSchema: AnySchemaObject, it: SchemaCxt) => AnySchema;
-export type CompileKeywordFunc = (schema: any, parentSchema: AnySchemaObject, it: SchemaObjCxt) => DataValidateFunction;
-export interface DataValidateFunction {
-    (...args: Parameters<ValidateFunction>): boolean | Promise<any>;
-    errors?: Partial<ErrorObject>[];
-}
-export interface SchemaValidateFunction {
-    (schema: any, data: any, parentSchema?: AnySchemaObject, dataCxt?: DataValidationCxt): boolean | Promise<any>;
-    errors?: Partial<ErrorObject>[];
-}
-export interface FuncKeywordDefinition extends _KeywordDef {
-    validate?: SchemaValidateFunction | DataValidateFunction;
-    compile?: CompileKeywordFunc;
-    schema?: boolean;
-    modifying?: boolean;
-    async?: boolean;
-    valid?: boolean;
-    errors?: boolean | "full";
-}
-export interface MacroKeywordDefinition extends FuncKeywordDefinition {
-    macro: MacroKeywordFunc;
-}
-export type KeywordDefinition = CodeKeywordDefinition | FuncKeywordDefinition | MacroKeywordDefinition;
-export type AddedKeywordDefinition = KeywordDefinition & {
-    type: JSONType[];
-    schemaType: JSONType[];
-};
-export interface KeywordErrorDefinition {
-    message: string | Code | ((cxt: KeywordErrorCxt) => string | Code);
-    params?: Code | ((cxt: KeywordErrorCxt) => Code);
-}
-export type Vocabulary = (KeywordDefinition | string)[];
-export interface KeywordErrorCxt {
-    gen: CodeGen;
-    keyword: string;
-    data: Name;
-    $data?: string | false;
-    schema: any;
-    parentSchema?: AnySchemaObject;
-    schemaCode: Code | number | boolean;
-    schemaValue: Code | number | boolean;
-    schemaType?: JSONType[];
-    errsCount?: Name;
-    params: KeywordCxtParams;
-    it: SchemaCxt;
-}
-export type KeywordCxtParams = {
-    [P in string]?: Code | string | number;
-};
-export type FormatValidator<T extends string | number> = (data: T) => boolean;
-export type FormatCompare<T extends string | number> = (data1: T, data2: T) => number | undefined;
-export type AsyncFormatValidator<T extends string | number> = (data: T) => Promise<boolean>;
-export interface FormatDefinition<T extends string | number> {
-    type?: T extends string ? "string" | undefined : "number";
-    validate: FormatValidator<T> | (T extends string ? string | RegExp : never);
-    async?: false | undefined;
-    compare?: FormatCompare<T>;
-}
-export interface AsyncFormatDefinition<T extends string | number> {
-    type?: T extends string ? "string" | undefined : "number";
-    validate: AsyncFormatValidator<T>;
-    async: true;
-    compare?: FormatCompare<T>;
-}
-export type AddedFormat = true | RegExp | FormatValidator<string> | FormatDefinition<string> | FormatDefinition<number> | AsyncFormatDefinition<string> | AsyncFormatDefinition<number>;
-export type Format = AddedFormat | string;
-export interface RegExpEngine {
-    (pattern: string, u: string): RegExpLike;
-    code: string;
-}
-export interface RegExpLike {
-    test: (s: string) => boolean;
-}
-export interface UriResolver {
-    parse(uri: string): URIComponent;
-    resolve(base: string, path: string): string;
-    serialize(component: URIComponent): string;
-}
-export {};

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

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=index.js.map

package/dist/node_modules/ajv/dist/types/json-schema.d.ts

@@ -1,125 +0,0 @@
-type StrictNullChecksWrapper<Name extends string, Type> = undefined extends null ? `strictNullChecks must be true in tsconfig to use ${Name}` : Type;
-type UnionToIntersection<U> = (U extends any ? (_: U) => void : never) extends (_: infer I) => void ? I : never;
-export type SomeJSONSchema = UncheckedJSONSchemaType<Known, true>;
-type UncheckedPartialSchema<T> = Partial<UncheckedJSONSchemaType<T, true>>;
-export type PartialSchema<T> = StrictNullChecksWrapper<"PartialSchema", UncheckedPartialSchema<T>>;
-type JSONType<T extends string, IsPartial extends boolean> = IsPartial extends true ? T | undefined : T;
-interface NumberKeywords {
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
-    multipleOf?: number;
-    format?: string;
-}
-interface StringKeywords {
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-}
-type UncheckedJSONSchemaType<T, IsPartial extends boolean> = (// these two unions allow arbitrary unions of types
-{
-    anyOf: readonly UncheckedJSONSchemaType<T, IsPartial>[];
-} | {
-    oneOf: readonly UncheckedJSONSchemaType<T, IsPartial>[];
-} | ({
-    type: readonly (T extends number ? JSONType<"number" | "integer", IsPartial> : T extends string ? JSONType<"string", IsPartial> : T extends boolean ? JSONType<"boolean", IsPartial> : never)[];
-} & UnionToIntersection<T extends number ? NumberKeywords : T extends string ? StringKeywords : T extends boolean ? {} : never>) | ((T extends number ? {
-    type: JSONType<"number" | "integer", IsPartial>;
-} & NumberKeywords : T extends string ? {
-    type: JSONType<"string", IsPartial>;
-} & StringKeywords : T extends boolean ? {
-    type: JSONType<"boolean", IsPartial>;
-} : T extends readonly [any, ...any[]] ? {
-    type: JSONType<"array", IsPartial>;
-    items: {
-        readonly [K in keyof T]-?: UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>;
-    } & {
-        length: T["length"];
-    };
-    minItems: T["length"];
-} & ({
-    maxItems: T["length"];
-} | {
-    additionalItems: false;
-}) : T extends readonly any[] ? {
-    type: JSONType<"array", IsPartial>;
-    items: UncheckedJSONSchemaType<T[0], false>;
-    contains?: UncheckedPartialSchema<T[0]>;
-    minItems?: number;
-    maxItems?: number;
-    minContains?: number;
-    maxContains?: number;
-    uniqueItems?: true;
-    additionalItems?: never;
-} : T extends Record<string, any> ? {
-    type: JSONType<"object", IsPartial>;
-    additionalProperties?: boolean | UncheckedJSONSchemaType<T[string], false>;
-    unevaluatedProperties?: boolean | UncheckedJSONSchemaType<T[string], false>;
-    properties?: IsPartial extends true ? Partial<UncheckedPropertiesSchema<T>> : UncheckedPropertiesSchema<T>;
-    patternProperties?: Record<string, UncheckedJSONSchemaType<T[string], false>>;
-    propertyNames?: Omit<UncheckedJSONSchemaType<string, false>, "type"> & {
-        type?: "string";
-    };
-    dependencies?: {
-        [K in keyof T]?: readonly (keyof T)[] | UncheckedPartialSchema<T>;
-    };
-    dependentRequired?: {
-        [K in keyof T]?: readonly (keyof T)[];
-    };
-    dependentSchemas?: {
-        [K in keyof T]?: UncheckedPartialSchema<T>;
-    };
-    minProperties?: number;
-    maxProperties?: number;
-} & (IsPartial extends true ? {
-    required: readonly (keyof T)[];
-} : [UncheckedRequiredMembers<T>] extends [never] ? {
-    required?: readonly UncheckedRequiredMembers<T>[];
-} : {
-    required: readonly UncheckedRequiredMembers<T>[];
-}) : T extends null ? {
-    type: JSONType<"null", IsPartial>;
-    nullable: true;
-} : never) & {
-    allOf?: readonly UncheckedPartialSchema<T>[];
-    anyOf?: readonly UncheckedPartialSchema<T>[];
-    oneOf?: readonly UncheckedPartialSchema<T>[];
-    if?: UncheckedPartialSchema<T>;
-    then?: UncheckedPartialSchema<T>;
-    else?: UncheckedPartialSchema<T>;
-    not?: UncheckedPartialSchema<T>;
-})) & {
-    [keyword: string]: any;
-    $id?: string;
-    $ref?: string;
-    $defs?: Record<string, UncheckedJSONSchemaType<Known, true>>;
-    definitions?: Record<string, UncheckedJSONSchemaType<Known, true>>;
-};
-export type JSONSchemaType<T> = StrictNullChecksWrapper<"JSONSchemaType", UncheckedJSONSchemaType<T, false>>;
-type Known = {
-    [key: string]: Known;
-} | [Known, ...Known[]] | Known[] | number | string | boolean | null;
-type UncheckedPropertiesSchema<T> = {
-    [K in keyof T]-?: (UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>) | {
-        $ref: string;
-    };
-};
-export type PropertiesSchema<T> = StrictNullChecksWrapper<"PropertiesSchema", UncheckedPropertiesSchema<T>>;
-type UncheckedRequiredMembers<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? never : K;
-}[keyof T];
-export type RequiredMembers<T> = StrictNullChecksWrapper<"RequiredMembers", UncheckedRequiredMembers<T>>;
-type Nullable<T> = undefined extends T ? {
-    nullable: true;
-    const?: null;
-    enum?: readonly (T | null)[];
-    default?: T | null;
-} : {
-    nullable?: false;
-    const?: T;
-    enum?: readonly T[];
-    default?: T;
-};
-export {};

package/dist/node_modules/ajv/dist/types/json-schema.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=json-schema.js.map

package/dist/node_modules/ajv/dist/types/jtd-schema.d.ts

@@ -1,174 +0,0 @@
-/** numeric strings */
-type NumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
-/** string strings */
-type StringType = "string" | "timestamp";
-/** Generic JTD Schema without inference of the represented type */
-export type SomeJTDSchemaType = (// ref
-{
-    ref: string;
-} | {
-    type: NumberType | StringType | "boolean";
-} | {
-    enum: string[];
-} | {
-    elements: SomeJTDSchemaType;
-} | {
-    values: SomeJTDSchemaType;
-} | {
-    properties: Record<string, SomeJTDSchemaType>;
-    optionalProperties?: Record<string, SomeJTDSchemaType>;
-    additionalProperties?: boolean;
-} | {
-    properties?: Record<string, SomeJTDSchemaType>;
-    optionalProperties: Record<string, SomeJTDSchemaType>;
-    additionalProperties?: boolean;
-} | {
-    discriminator: string;
-    mapping: Record<string, SomeJTDSchemaType>;
-} | {}) & {
-    nullable?: boolean;
-    metadata?: Record<string, unknown>;
-    definitions?: Record<string, SomeJTDSchemaType>;
-};
-/** required keys of an object, not undefined */
-type RequiredKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? never : K;
-}[keyof T];
-/** optional or undifined-able keys of an object */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never;
-}[keyof T];
-/** type is true if T is a union type */
-type IsUnion_<T, U extends T = T> = false extends (T extends unknown ? ([U] extends [T] ? false : true) : never) ? false : true;
-type IsUnion<T> = IsUnion_<T>;
-/** type is true if T is identically E */
-type TypeEquality<T, E> = [T] extends [E] ? ([E] extends [T] ? true : false) : false;
-/** type is true if T or null is identically E or null*/
-type NullTypeEquality<T, E> = TypeEquality<T | null, E | null>;
-/** gets only the string literals of a type or null if a type isn't a string literal */
-type EnumString<T> = [T] extends [never] ? null : T extends string ? string extends T ? null : T : null;
-/** true if type is a union of string literals */
-type IsEnum<T> = null extends EnumString<T> ? false : true;
-/** true only if all types are array types (not tuples) */
-type IsElements<T> = false extends IsUnion<T> ? [T] extends [readonly unknown[]] ? undefined extends T[0.5] ? false : true : false : false;
-/** true if the the type is a values type */
-type IsValues<T> = false extends IsUnion<T> ? TypeEquality<keyof T, string> : false;
-/** true if type is a properties type and Union is false, or type is a discriminator type and Union is true */
-type IsRecord<T, Union extends boolean> = Union extends IsUnion<T> ? null extends EnumString<keyof T> ? false : true : false;
-/** true if type represents an empty record */
-type IsEmptyRecord<T> = [T] extends [Record<string, never>] ? [T] extends [never] ? false : true : false;
-/** actual schema */
-export type JTDSchemaType<T, D extends Record<string, unknown> = Record<string, never>> = (// refs - where null wasn't specified, must match exactly
-(null extends EnumString<keyof D> ? never : ({
-    [K in keyof D]: [T] extends [D[K]] ? {
-        ref: K;
-    } : never;
-}[keyof D] & {
-    nullable?: false;
-}) | (null extends T ? {
-    [K in keyof D]: [Exclude<T, null>] extends [Exclude<D[K], null>] ? {
-        ref: K;
-    } : never;
-}[keyof D] & {
-    nullable: true;
-} : never)) | (unknown extends T ? {
-    nullable?: boolean;
-} : never) | ((true extends NullTypeEquality<T, number> ? {
-    type: NumberType;
-} : true extends NullTypeEquality<T, boolean> ? {
-    type: "boolean";
-} : true extends NullTypeEquality<T, string> ? {
-    type: StringType;
-} : true extends NullTypeEquality<T, Date> ? {
-    type: "timestamp";
-} : true extends IsEnum<Exclude<T, null>> ? {
-    enum: EnumString<Exclude<T, null>>[];
-} : true extends IsElements<Exclude<T, null>> ? T extends readonly (infer E)[] ? {
-    elements: JTDSchemaType<E, D>;
-} : never : true extends IsEmptyRecord<Exclude<T, null>> ? {
-    properties: Record<string, never>;
-    optionalProperties?: Record<string, never>;
-} | {
-    optionalProperties: Record<string, never>;
-} : true extends IsValues<Exclude<T, null>> ? T extends Record<string, infer V> ? {
-    values: JTDSchemaType<V, D>;
-} : never : true extends IsRecord<Exclude<T, null>, false> ? ([RequiredKeys<Exclude<T, null>>] extends [never] ? {
-    properties?: Record<string, never>;
-} : {
-    properties: {
-        [K in RequiredKeys<T>]: JTDSchemaType<T[K], D>;
-    };
-}) & ([OptionalKeys<Exclude<T, null>>] extends [never] ? {
-    optionalProperties?: Record<string, never>;
-} : {
-    optionalProperties: {
-        [K in OptionalKeys<T>]: JTDSchemaType<Exclude<T[K], undefined>, D>;
-    };
-}) & {
-    additionalProperties?: boolean;
-} : true extends IsRecord<Exclude<T, null>, true> ? {
-    [K in keyof Exclude<T, null>]-?: Exclude<T, null>[K] extends string ? {
-        discriminator: K;
-        mapping: {
-            [M in Exclude<T, null>[K]]: JTDSchemaType<Omit<T extends Record<K, M> ? T : never, K>, D>;
-        };
-    } : never;
-}[keyof Exclude<T, null>] : never) & (null extends T ? {
-    nullable: true;
-} : {
-    nullable?: false;
-}))) & {
-    metadata?: Record<string, unknown>;
-    definitions?: {
-        [K in keyof D]: JTDSchemaType<D[K], D>;
-    };
-};
-type JTDDataDef<S, D extends Record<string, unknown>> = // ref
-(S extends {
-    ref: string;
-} ? D extends {
-    [K in S["ref"]]: infer V;
-} ? JTDDataDef<V, D> : never : S extends {
-    type: NumberType;
-} ? number : S extends {
-    type: "boolean";
-} ? boolean : S extends {
-    type: "string";
-} ? string : S extends {
-    type: "timestamp";
-} ? string | Date : S extends {
-    enum: readonly (infer E)[];
-} ? string extends E ? never : [E] extends [string] ? E : never : S extends {
-    elements: infer E;
-} ? JTDDataDef<E, D>[] : S extends {
-    properties: Record<string, unknown>;
-    optionalProperties?: Record<string, unknown>;
-    additionalProperties?: boolean;
-} ? {
-    -readonly [K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D>;
-} & {
-    -readonly [K in keyof S["optionalProperties"]]+?: JTDDataDef<S["optionalProperties"][K], D>;
-} & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown) : S extends {
-    properties?: Record<string, unknown>;
-    optionalProperties: Record<string, unknown>;
-    additionalProperties?: boolean;
-} ? {
-    -readonly [K in keyof S["properties"]]-?: JTDDataDef<S["properties"][K], D>;
-} & {
-    -readonly [K in keyof S["optionalProperties"]]+?: JTDDataDef<S["optionalProperties"][K], D>;
-} & ([S["additionalProperties"]] extends [true] ? Record<string, unknown> : unknown) : S extends {
-    values: infer V;
-} ? Record<string, JTDDataDef<V, D>> : S extends {
-    discriminator: infer M;
-    mapping: Record<string, unknown>;
-} ? [M] extends [string] ? {
-    [K in keyof S["mapping"]]: JTDDataDef<S["mapping"][K], D> & {
-        [KM in M]: K;
-    };
-}[keyof S["mapping"]] : never : unknown) | (S extends {
-    nullable: true;
-} ? null : never);
-export type JTDDataType<S> = S extends {
-    definitions: Record<string, unknown>;
-} ? JTDDataDef<S, S["definitions"]> : JTDDataDef<S, Record<string, never>>;
-export {};

package/dist/node_modules/ajv/dist/types/jtd-schema.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=jtd-schema.js.map

package/dist/node_modules/ajv/dist/vocabularies/applicator/additionalItems.d.ts

@@ -1,8 +0,0 @@
-import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
-import type { KeywordCxt } from "../../compile/validate";
-export type AdditionalItemsError = ErrorObject<"additionalItems", {
-    limit: number;
-}, AnySchema>;
-declare const def: CodeKeywordDefinition;
-export declare function validateAdditionalItems(cxt: KeywordCxt, items: AnySchema[]): void;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/applicator/additionalItems.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAdditionalItems = void 0;
-const codegen_1 = require("../../compile/codegen");
-const util_1 = require("../../compile/util");
-const error = {
-    message: ({ params: { len } }) => (0, codegen_1.str) `must NOT have more than ${len} items`,
-    params: ({ params: { len } }) => (0, codegen_1._) `{limit: ${len}}`,
-};
-const def = {
-    keyword: "additionalItems",
-    type: "array",
-    schemaType: ["boolean", "object"],
-    before: "uniqueItems",
-    error,
-    code(cxt) {
-        const { parentSchema, it } = cxt;
-        const { items } = parentSchema;
-        if (!Array.isArray(items)) {
-            (0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas');
-            return;
-        }
-        validateAdditionalItems(cxt, items);
-    },
-};
-function validateAdditionalItems(cxt, items) {
-    const { gen, schema, data, keyword, it } = cxt;
-    it.items = true;
-    const len = gen.const("len", (0, codegen_1._) `${data}.length`);
-    if (schema === false) {
-        cxt.setParams({ len: items.length });
-        cxt.pass((0, codegen_1._) `${len} <= ${items.length}`);
-    }
-    else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
-        const valid = gen.var("valid", (0, codegen_1._) `${len} <= ${items.length}`); // TODO var
-        gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
-        cxt.ok(valid);
-    }
-    function validateItems(valid) {
-        gen.forRange("i", items.length, len, (i) => {
-            cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid);
-            if (!it.allErrors)
-                gen.if((0, codegen_1.not)(valid), () => gen.break());
-        });
-    }
-}
-exports.validateAdditionalItems = validateAdditionalItems;
-exports.default = def;
-//# sourceMappingURL=additionalItems.js.map

package/dist/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.d.ts

@@ -1,6 +0,0 @@
-import type { CodeKeywordDefinition, AddedKeywordDefinition, ErrorObject, AnySchema } from "../../types";
-export type AdditionalPropertiesError = ErrorObject<"additionalProperties", {
-    additionalProperty: string;
-}, AnySchema>;
-declare const def: CodeKeywordDefinition & AddedKeywordDefinition;
-export default def;

package/dist/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const code_1 = require("../code");
-const codegen_1 = require("../../compile/codegen");
-const names_1 = require("../../compile/names");
-const util_1 = require("../../compile/util");
-const error = {
-    message: "must NOT have additional properties",
-    params: ({ params }) => (0, codegen_1._) `{additionalProperty: ${params.additionalProperty}}`,
-};
-const def = {
-    keyword: "additionalProperties",
-    type: ["object"],
-    schemaType: ["boolean", "object"],
-    allowUndefined: true,
-    trackErrors: true,
-    error,
-    code(cxt) {
-        const { gen, schema, parentSchema, data, errsCount, it } = cxt;
-        /* istanbul ignore if */
-        if (!errsCount)
-            throw new Error("ajv implementation error");
-        const { allErrors, opts } = it;
-        it.props = true;
-        if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
-            return;
-        const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
-        const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
-        checkAdditionalProperties();
-        cxt.ok((0, codegen_1._) `${errsCount} === ${names_1.default.errors}`);
-        function checkAdditionalProperties() {
-            gen.forIn("key", data, (key) => {
-                if (!props.length && !patProps.length)
-                    additionalPropertyCode(key);
-                else
-                    gen.if(isAdditional(key), () => additionalPropertyCode(key));
-            });
-        }
-        function isAdditional(key) {
-            let definedProp;
-            if (props.length > 8) {
-                // TODO maybe an option instead of hard-coded 8?
-                const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
-                definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
-            }
-            else if (props.length) {
-                definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._) `${key} === ${p}`));
-            }
-            else {
-                definedProp = codegen_1.nil;
-            }
-            if (patProps.length) {
-                definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._) `${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
-            }
-            return (0, codegen_1.not)(definedProp);
-        }
-        function deleteAdditional(key) {
-            gen.code((0, codegen_1._) `delete ${data}[${key}]`);
-        }
-        function additionalPropertyCode(key) {
-            if (opts.removeAdditional === "all" || (opts.removeAdditional && schema === false)) {
-                deleteAdditional(key);
-                return;
-            }
-            if (schema === false) {
-                cxt.setParams({ additionalProperty: key });
-                cxt.error();
-                if (!allErrors)
-                    gen.break();
-                return;
-            }
-            if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
-                const valid = gen.name("valid");
-                if (opts.removeAdditional === "failing") {
-                    applyAdditionalSchema(key, valid, false);
-                    gen.if((0, codegen_1.not)(valid), () => {
-                        cxt.reset();
-                        deleteAdditional(key);
-                    });
-                }
-                else {
-                    applyAdditionalSchema(key, valid);
-                    if (!allErrors)
-                        gen.if((0, codegen_1.not)(valid), () => gen.break());
-                }
-            }
-        }
-        function applyAdditionalSchema(key, valid, errors) {
-            const subschema = {
-                keyword: "additionalProperties",
-                dataProp: key,
-                dataPropType: util_1.Type.Str,
-            };
-            if (errors === false) {
-                Object.assign(subschema, {
-                    compositeRule: true,
-                    createErrors: false,
-                    allErrors: false,
-                });
-            }
-            cxt.subschema(subschema, valid);
-        }
-    },
-};
-exports.default = def;
-//# sourceMappingURL=additionalProperties.js.map

package/dist/node_modules/ajv/dist/vocabularies/applicator/allOf.d.ts

@@ -1,3 +0,0 @@
-import type { CodeKeywordDefinition } from "../../types";
-declare const def: CodeKeywordDefinition;
-export default def;