json-schema-library 6.1.0 → 7.0.0

package/dist/module/lib/draft06/validation/keyword.js

@@ -29,7 +29,11 @@ const KeywordValidation = {
             return undefined;
         }
         if (schema.exclusiveMaximum <= value) {
-            return core.errors.maximumError({ maximum: schema.exclusiveMaximum, length: value, pointer });
+            return core.errors.maximumError({
+                maximum: schema.exclusiveMaximum,
+                length: value,
+                pointer
+            });
         }
         return undefined;
     },
@@ -38,7 +42,11 @@ const KeywordValidation = {
             return undefined;
         }
         if (schema.exclusiveMinimum >= value) {
-            return core.errors.minimumError({ minimum: schema.exclusiveMinimum, length: value, pointer });
+            return core.errors.minimumError({
+                minimum: schema.exclusiveMinimum,
+                length: value,
+                pointer
+            });
         }
         return undefined;
     },
@@ -81,11 +89,11 @@ const KeywordValidation = {
         }
         const errors = [];
         const keys = Object.keys(value);
-        const patterns = Object.keys(pp).map(expr => ({
+        const patterns = Object.keys(pp).map((expr) => ({
             regex: new RegExp(expr),
             patternSchema: pp[expr]
         }));
-        keys.forEach(key => {
+        keys.forEach((key) => {
             let patternFound = false;
             for (let i = 0, l = patterns.length; i < l; i += 1) {
                 if (patterns[i].regex.test(key)) {
@@ -93,7 +101,9 @@ const KeywordValidation = {
                     // for a boolean schema `false`, always invalidate
                     if (patterns[i].patternSchema === false) {
                         errors.push(core.errors.patternPropertiesError({
-                            key, pointer, patterns: Object.keys(pp).join(",")
+                            key,
+                            pointer,
+                            patterns: Object.keys(pp).join(",")
                         }));
                         return;
                     }
@@ -109,7 +119,9 @@ const KeywordValidation = {
             if (patternFound === false && schema.additionalProperties === false) {
                 // this is an arrangement with additionalProperties
                 errors.push(core.errors.patternPropertiesError({
-                    key, pointer, patterns: Object.keys(pp).join(",")
+                    key,
+                    pointer,
+                    patterns: Object.keys(pp).join(",")
                 }));
             }
         });
@@ -139,7 +151,7 @@ const KeywordValidation = {
         const errors = [];
         const properties = Object.keys(value);
         const propertySchema = { ...schema.propertyNames, type: "string" };
-        properties.forEach(prop => {
+        properties.forEach((prop) => {
             const validationResult = core.validate(prop, propertySchema, `${pointer}/${prop}`);
             if (validationResult.length > 0) {
                 errors.push(core.errors.invalidPropertyNameError({

package/dist/module/lib/draft06/validation/type.js

@@ -5,26 +5,27 @@
  * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
  * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
  */
-export default {
+const validationType = {
     array: (core, schema, value, pointer) => core.typeKeywords.array
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer)),
     object: (core, schema, value, pointer) => core.typeKeywords.object
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer)),
     string: (core, schema, value, pointer) => core.typeKeywords.string
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer)),
     integer: (core, schema, value, pointer) => core.typeKeywords.number
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer)),
     number: (core, schema, value, pointer) => core.typeKeywords.number
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
-    "boolean": (core, schema, value, pointer) => core.typeKeywords.boolean
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer)),
-    "null": (core, schema, value, pointer) => core.typeKeywords.null
-        .filter(key => schema && schema[key] != null)
-        .map(key => core.validateKeyword[key](core, schema, value, pointer))
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer)),
+    boolean: (core, schema, value, pointer) => core.typeKeywords.boolean
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer)),
+    null: (core, schema, value, pointer) => core.typeKeywords.null
+        .filter((key) => schema && schema[key] != null)
+        .map((key) => core.validateKeyword[key](core, schema, value, pointer))
 };
+export default validationType;

package/dist/module/lib/draft07/index.js

@@ -0,0 +1,96 @@
+import addRemoteSchema from "../addRemoteSchema";
+import compileSchema from "../draft06/compile";
+import { each } from "../each";
+import { eachSchema } from "../eachSchema";
+import ERRORS from "../validation/errors";
+import FORMATS from "../validation/format";
+import getSchema from "../getSchema";
+import getTemplate from "../getTemplate";
+import isValid from "../isValid";
+import KEYWORDS from "../draft06/validation/keyword";
+import merge from "../utils/merge";
+import resolveAllOf from "../resolveAllOf";
+import resolveAnyOf from "../resolveAnyOf";
+import resolveOneOf from "../resolveOneOf.strict";
+import resolveRef from "../resolveRef.strict";
+import createSchemaOf from "../createSchemaOf";
+import getChildSchemaSelection from "../getChildSchemaSelection";
+import step from "../step";
+import TYPES from "../draft06/validation/type";
+import validate from "../validate";
+import { Draft } from "../draft";
+const draft07Config = {
+    typeKeywords: {
+        array: ["enum", "contains", "items", "minItems", "maxItems", "uniqueItems", "not", "if"],
+        boolean: ["enum", "not"],
+        object: [
+            "additionalProperties",
+            "dependencies",
+            "enum",
+            "format",
+            "minProperties",
+            "maxProperties",
+            "patternProperties",
+            "properties",
+            "propertyNames",
+            "required",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf",
+            "if"
+        ],
+        string: [
+            "enum",
+            "format",
+            "maxLength",
+            "minLength",
+            "pattern",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf",
+            "if"
+        ],
+        number: [
+            "enum",
+            "exclusiveMaximum",
+            "exclusiveMinimum",
+            "format",
+            "maximum",
+            "minimum",
+            "multipleOf",
+            "not",
+            "oneOf",
+            "allOf",
+            "anyOf",
+            "if"
+        ],
+        null: ["enum", "format", "not", "oneOf", "allOf", "anyOf"]
+    },
+    validateKeyword: KEYWORDS,
+    validateType: TYPES,
+    validateFormat: FORMATS,
+    errors: ERRORS,
+    addRemoteSchema,
+    compileSchema,
+    createSchemaOf,
+    each,
+    eachSchema,
+    getChildSchemaSelection,
+    getSchema,
+    getTemplate,
+    isValid,
+    resolveAllOf,
+    resolveAnyOf,
+    resolveOneOf,
+    resolveRef,
+    step,
+    validate
+};
+class Draft07 extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draft07Config, config), schema);
+    }
+}
+export { Draft07, draft07Config };

package/dist/module/lib/each.js

@@ -8,7 +8,7 @@ import getTypeOf from "./getTypeOf";
  * @param [schema] - the schema matching the data. Defaults to rootSchema
  * @param [pointer] - pointer to current data. Default to rootPointer
  */
-export default function each(core, data, callback, schema = core.rootSchema, pointer = "#") {
+export function each(core, data, callback, schema = core.rootSchema, pointer = "#") {
     callback(schema, data, pointer);
     const dataType = getTypeOf(data);
     if (dataType === "object") {

package/dist/module/lib/eachSchema.js

@@ -1,35 +1,44 @@
 import gp from "gson-pointer";
 import getTypeDefs from "./schema/getTypeDefs";
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
 function nextTypeDefs(schema, pointer) {
-    if (this.callback(schema, pointer) === true) { // eslint-disable-line no-invalid-this
+    if (this.callback(schema, pointer) === true) {
+        // eslint-disable-line no-invalid-this
         return; // stop iteration
     }
     const defs = getTypeDefs(schema);
     // eslint-disable-next-line no-invalid-this
-    defs.forEach(next => this.nextTypeDefs(next.def, gp.join(pointer, next.pointer, false)));
+    defs.forEach((next) => this.nextTypeDefs(next.def, gp.join(pointer, next.pointer, false)));
 }
-function eachDefinition(walk, schema, pointer) {
-    Object.keys(schema.definitions)
-        .forEach(defId => {
-        if (schema.definitions[defId] === false || isObject(schema.definitions[defId])) {
-            walk.nextTypeDefs(schema.definitions[defId], gp.join(pointer, "definitions", defId, false));
+function eachDefinition(walk, schema, pointer, key = "definitions") {
+    const defs = schema[key];
+    Object.keys(defs).forEach((defId) => {
+        if (defs[defId] === false || isObject(defs[defId])) {
+            walk.nextTypeDefs(defs[defId], gp.join(pointer, key, defId, false));
             return;
         }
-        console.log(`Invalid schema in ${pointer}/definitions/${defId}`);
+        console.log(`Invalid schema in ${pointer}/${key}/${defId}`);
     });
 }
-export default function eachSchema(schema, callback, pointer = "#") {
+export function eachSchema(schema, callback, pointer = "#") {
     const walk = { callback, nextTypeDefs };
     walk.nextTypeDefs(schema, pointer);
-    if (schema.definitions == null) {
-        return;
+    if (schema.definitions != null) {
+        walk.callback = (defschema, schemaPointer) => {
+            callback(defschema, schemaPointer);
+            if (defschema.definitions != null) {
+                eachDefinition(walk, defschema, schemaPointer);
+            }
+        };
+        eachDefinition(walk, schema, pointer);
+    }
+    if (schema.$defs != null) {
+        walk.callback = (defschema, schemaPointer) => {
+            callback(defschema, schemaPointer);
+            if (defschema.definitions != null) {
+                eachDefinition(walk, defschema, schemaPointer);
+            }
+        };
+        eachDefinition(walk, schema, pointer, "$defs");
     }
-    walk.callback = (defschema, schemaPointer) => {
-        callback(defschema, schemaPointer);
-        if (defschema.definitions != null) {
-            eachDefinition(walk, defschema, schemaPointer);
-        }
-    };
-    eachDefinition(walk, schema, pointer);
 }

package/dist/module/lib/getChildSchemaSelection.js

@@ -4,7 +4,7 @@ import { isJSONError } from "./types";
  * could be added at the given property (e.g. item-index), thus an array of options is returned. In all other cases
  * a list with a single item will be returned
  *
- * @param core          - core to use
+ * @param core        - core to use
  * @param property    - parent schema of following property
  * @param [schema]    - parent schema of following property
  * @return

package/dist/module/lib/getSchema.js

@@ -20,13 +20,14 @@ export default function getSchema(core, pointer, data, schema = core.rootSchema)
 }
 function _get(core, schema, frags, pointer, data = emptyObject) {
     if (frags.length === 0) {
-        return schema;
+        return core.resolveRef(schema);
     }
     const key = frags.shift(); // step key
     schema = core.step(key, schema, data, pointer); // step schema
     if (isJSONError(schema)) {
         return schema;
     }
+    // @ts-ignore
     data = data[key]; // step data
     return _get(core, schema, frags, `${pointer}/${key}`, data);
 }

package/dist/module/lib/getTemplate.js

@@ -197,8 +197,8 @@ const TYPE = {
     // build array type of items, ignores additionalItems
     array: (core, schema, data, pointer, opts) => {
         const template = schema.default === undefined ? [] : schema.default;
-        const d = data || [];
         schema.minItems = schema.minItems || 0;
+        const d = data || [];
         // items are undefined
         if (schema.items == null) {
             return d;
@@ -268,6 +268,6 @@ function getDefault(schema, templateValue, initValue) {
     return schema.default;
 }
 export default (core, data, schema = core.rootSchema, opts = defaultOptions) => {
-    cache = { mi: ".." };
+    cache = { mi: {} };
     return getTemplate(core, data, schema, "#", opts);
 };

package/dist/module/lib/jsoneditor/index.js

@@ -0,0 +1,16 @@
+import merge from "../utils/merge";
+import resolveOneOf from "../resolveOneOf.fuzzy";
+import resolveRef from "../resolveRef.merge";
+import { Draft } from "../draft";
+import { draft07Config } from "../draft07";
+const draftJsonEditorConfig = {
+    ...draft07Config,
+    resolveOneOf,
+    resolveRef
+};
+class JsonEditor extends Draft {
+    constructor(schema, config = {}) {
+        super(merge(draftJsonEditorConfig, config), schema);
+    }
+}
+export { JsonEditor, draftJsonEditorConfig };

package/dist/module/lib/resolveOneOf.strict.js

@@ -1,5 +1,8 @@
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
+import settings from "./config/settings";
+import { isJSONError } from "./types";
+const { DECLARATOR_ONEOF } = settings;
 /**
  * Selects and returns a oneOf schema for the given data
  *
@@ -10,6 +13,41 @@ import flattenArray from "./utils/flattenArray";
  * @return oneOf schema or an error
  */
 export default function resolveOneOf(core, data, schema = core.rootSchema, pointer = "#") {
+    // !keyword: oneOfProperty
+    // an additional <DECLARATOR_ONEOF> (default `oneOfProperty`) on the schema will exactly determine the
+    // oneOf value (if set in data)
+    // @fixme
+    // abort if no data is given an DECLARATOR_ONEOF is set (used by getChildSchemaSelection)
+    // this case (data != null) should not be necessary
+    if (data != null && schema[DECLARATOR_ONEOF]) {
+        const errors = [];
+        const oneOfProperty = schema[DECLARATOR_ONEOF];
+        const oneOfValue = data[schema[DECLARATOR_ONEOF]];
+        if (oneOfValue === undefined) {
+            return core.errors.missingOneOfPropertyError({ property: oneOfProperty, pointer });
+        }
+        for (let i = 0; i < schema.oneOf.length; i += 1) {
+            const one = core.resolveRef(schema.oneOf[i]);
+            const oneOfPropertySchema = core.step(oneOfProperty, one, data, pointer);
+            if (isJSONError(oneOfPropertySchema)) {
+                return oneOfPropertySchema;
+            }
+            let result = flattenArray(core.validate(oneOfValue, oneOfPropertySchema, pointer));
+            result = result.filter(errorOrPromise);
+            if (result.length > 0) {
+                errors.push(...result);
+            }
+            else {
+                return one; // return resolved schema
+            }
+        }
+        return core.errors.oneOfPropertyError({
+            property: oneOfProperty,
+            value: oneOfValue,
+            pointer,
+            errors
+        });
+    }
     const matches = [];
     const errors = [];
     for (let i = 0; i < schema.oneOf.length; i += 1) {
@@ -30,13 +68,13 @@ export default function resolveOneOf(core, data, schema = core.rootSchema, point
         return core.errors.multipleOneOfError({
             value: data,
             pointer,
-            matches,
+            matches
         });
     }
     return core.errors.oneOfError({
         value: JSON.stringify(data),
         pointer,
         oneOf: schema.oneOf,
-        errors,
+        errors
     });
 }

package/dist/module/lib/schema/getTypeDefs.js

@@ -2,7 +2,7 @@ import gp from "gson-pointer";
 import { get } from "gson-query";
 import getTypeId from "./getTypeId";
 import types from "./types";
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
 /**
  * Returns a list of all (direct) type definitions from the given schema
  * @param schema
@@ -29,7 +29,7 @@ export default function getTypeDefs(schema) {
     if (type.definitions == null) {
         return defs;
     }
-    type.definitions.forEach(query => {
+    type.definitions.forEach((query) => {
         get(schema, query, (value, key, parent, pointer) => {
             if (isObject(value) && getTypeId(value)) {
                 defs.push({ pointer: gp.join(gp.split(pointer), false), def: value });

package/dist/module/lib/schema/getTypeId.js

@@ -1,6 +1,7 @@
 import types from "./types";
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
-const typeKeywords = Object.keys(types).filter(id => types[id].type === false);
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const typeKeywords = Object.keys(types).filter((id) => types[id].type === false);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 /**
  * @throws Error    on multiple matches (invalid schema)
  *
@@ -15,10 +16,11 @@ export default function getTypeId(schema) {
     if (schema.enum) {
         return "enum";
     }
+    // @ts-ignore
     if (types[schema.type] || Array.isArray(schema.type)) {
         return schema.type;
     }
-    const ids = typeKeywords.filter(type => schema[type]);
+    const ids = typeKeywords.filter((type) => schema[type]);
     if (ids.length === 1) {
         return ids[0];
     }
@@ -26,14 +28,16 @@ export default function getTypeId(schema) {
         // @expensive, guess type object
         for (let i = 0, l = types.object.keywords.length; i < l; i += 1) {
             const keyword = types.object.keywords[i];
-            if (schema.hasOwnProperty(keyword)) { // eslint-disable-line
+            if (hasOwnProperty.call(schema, keyword)) {
+                // eslint-disable-line
                 return "object";
             }
         }
         // @expensive, guess type array
         for (let i = 0, l = types.array.keywords.length; i < l; i += 1) {
             const keyword = types.array.keywords[i];
-            if (schema.hasOwnProperty(keyword)) { // eslint-disable-line
+            if (hasOwnProperty.call(schema, keyword)) {
+                // eslint-disable-line
                 return "array";
             }
         }

package/dist/module/lib/schema/types.js

@@ -1,4 +1,4 @@
-export default {
+const Types = {
     $ref: {
         type: false
     },
@@ -13,14 +13,22 @@ export default {
     array: {
         type: true,
         // ignore additionalItems:TypeDef, when items:TypeDef
-        definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not", "items", "items/*", "additionalItems"],
+        definitions: [
+            "allOf/*",
+            "anyOf/*",
+            "oneOf/*",
+            "not",
+            "items",
+            "items/*",
+            "additionalItems"
+        ],
         validationKeywords: ["minItems", "maxItems", "uniqueItems"],
         keywords: ["items", "additionalItems", "minItems", "maxItems", "uniqueItems"]
     },
-    "boolean": {
+    boolean: {
         type: true
     },
-    "enum": {
+    enum: {
         type: false
     },
     integer: {
@@ -37,7 +45,7 @@ export default {
         definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not"],
         validationKeywords: ["minimum", "maximum", "multipleOf"]
     },
-    "null": {
+    null: {
         type: true
     },
     object: {
@@ -45,11 +53,26 @@ export default {
         // patternProperties also validate properties
         // dependencies:(string, TypeDef) extend current TypeDef
         // additional Properties validate only remaining properties (after properties & pattern)
-        definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not",
-            "properties/*", "additionalProperties", "patternProperties/*", "dependencies/*"],
+        definitions: [
+            "allOf/*",
+            "anyOf/*",
+            "oneOf/*",
+            "not",
+            "properties/*",
+            "additionalProperties",
+            "patternProperties/*",
+            "dependencies/*"
+        ],
         validationKeywords: ["minProperties", "maxProperties", "required"],
-        keywords: ["properties", "additionalProperties", "patternProperties", "dependencies", "minProperties",
-            "maxProperties", "required"]
+        keywords: [
+            "properties",
+            "additionalProperties",
+            "patternProperties",
+            "dependencies",
+            "minProperties",
+            "maxProperties",
+            "required"
+        ]
     },
     oneOf: {
         type: false,
@@ -61,3 +84,4 @@ export default {
         validationKeywords: ["minLength", "maxLength", "pattern"]
     }
 };
+export default Types;

package/dist/module/lib/step.js

@@ -168,7 +168,8 @@ export default function step(core, key, schema, data, pointer = "#") {
     if (Array.isArray(schema.type)) {
         const dataType = getTypeOf(data);
         if (schema.type.includes(dataType)) {
-            return stepType[dataType](core, key, schema, data, pointer);
+            // @ts-ignore
+            return stepType[dataType](core, `${key}`, schema, data, pointer);
         }
         return core.errors.typeError({
             value: data,
@@ -178,8 +179,10 @@ export default function step(core, key, schema, data, pointer = "#") {
         });
     }
     const expectedType = schema.type || getTypeOf(data);
-    if (stepType[expectedType]) {
-        return stepType[expectedType](core, key, schema, data, pointer);
+    // @ts-ignore
+    const stepFunction = stepType[expectedType];
+    if (stepFunction) {
+        return stepFunction(core, `${key}`, schema, data, pointer);
     }
     return new Error(`Unsupported schema type ${schema.type} for key ${key}`);
 }

package/dist/module/lib/utils/createCustomError.js

@@ -1,6 +1,6 @@
 import __ from "./__";
-function dashCase(str) {
-    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+function dashCase(text) {
+    return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 export function createError(name, data) {
     return {
@@ -13,11 +13,11 @@ export function createError(name, data) {
 }
 /**
  * Creates a custom Error-Constructor which instances may be identified by `customError instanceof Error`. Its messages
- * are defined by strings-object __@see config/strings.ts
+ * are defined by strings-object @see config/strings.ts
  *
  * @param name - id of error (camelcased)
  * @return error constructor function
  */
-export default function createCustomError(name) {
+export function createCustomError(name) {
     return createError.bind(null, name);
 }

package/dist/module/lib/utils/flattenArray.js

@@ -1,10 +1,11 @@
 export default function flattenArray(list, result = []) {
     for (let i = 0; i < list.length; i += 1) {
-        if (Array.isArray(list[i])) {
-            flattenArray(list[i], result);
+        const item = list[i];
+        if (Array.isArray(item)) {
+            flattenArray(item, result);
         }
         else {
-            result.push(list[i]);
+            result.push(item);
         }
     }
     return result;

package/dist/module/lib/utils/merge.js

@@ -1,4 +1,5 @@
 import deepmerge from "deepmerge";
+// @ts-ignore
 const overwriteMerge = (destinationArray, sourceArray) => sourceArray;
 /**
  * returns a new json-schema, where properties are combined and arrays are replaced

package/dist/module/lib/utils/punycode.ucs2decode.js

@@ -20,12 +20,13 @@ export default function ucs2decode(string) {
     const length = string.length;
     while (counter < length) {
         const value = string.charCodeAt(counter++);
-        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
             // It's a high surrogate, and there is a next character.
             const extra = string.charCodeAt(counter++);
             // eslint-disable-next-line eqeqeq
-            if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
-                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+            if ((extra & 0xfc00) == 0xdc00) {
+                // Low surrogate.
+                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
             }
             else {
                 // It's an unmatched surrogate; only append this code unit, in case the

package/dist/module/lib/validate.js

@@ -58,5 +58,6 @@ export default function validate(core, value, schema = core.rootSchema, pointer
     }
     const errors = flattenArray(core.validateType[receivedType](core, schema, value, pointer));
     // also promises may be passed along (validateAsync)
+    // @ts-ignore
     return errors.filter(errorOrPromise);
 }

package/dist/module/lib/validation/errors.js

@@ -1,5 +1,5 @@
 /* eslint no-invalid-this: 0 */
-import createCustomError from "../utils/createCustomError";
+import { createCustomError } from "../utils/createCustomError";
 const errors = {
     additionalItemsError: createCustomError("AdditionalItemsError"),
     additionalPropertiesError: createCustomError("AdditionalPropertiesError"),