z-schema 10.0.0 → 12.0.0

package/dist/schema-validator.js

@@ -119,8 +119,7 @@ const SchemaValidators = {
     items: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
         if (Array.isArray(schema.items)) {
-            let idx = schema.items.length;
-            while (idx--) {
+            for (let idx = 0; idx < schema.items.length; idx++) {
                 report.path.push('items');
                 report.path.push(idx);
                 this.validateSchema(report, schema.items[idx]);
@@ -140,7 +139,7 @@ const SchemaValidators = {
         if (this.options.forceAdditional === true && schema.additionalItems === undefined && Array.isArray(schema.items)) {
             report.addError('KEYWORD_UNDEFINED_STRICT', ['additionalItems'], undefined, schema, 'additionalItems');
         }
-        // custome - assume defined false mode
+        // custom - assume defined false mode
         if (this.options.assumeAdditional && schema.additionalItems === undefined && Array.isArray(schema.items)) {
             schema.additionalItems = false;
         }
@@ -196,9 +195,8 @@ const SchemaValidators = {
             report.addError('KEYWORD_MUST_BE', ['required', 'an array with at least one element'], undefined, schema, 'required');
         }
         else {
-            let idx = schema.required.length;
-            while (idx--) {
-                if (typeof schema.required[idx] !== 'string') {
+            for (const item of schema.required) {
+                if (typeof item !== 'string') {
                     report.addError('KEYWORD_VALUE_TYPE', ['required', 'string'], undefined, schema, 'required');
                 }
             }
@@ -225,9 +223,7 @@ const SchemaValidators = {
             return;
         }
         const keys = Object.keys(schema.properties);
-        let idx = keys.length;
-        while (idx--) {
-            const key = keys[idx];
+        for (const key of keys) {
             const val = schema.properties[key];
             report.path.push('properties');
             report.path.push(key);
@@ -239,7 +235,7 @@ const SchemaValidators = {
         if (this.options.forceAdditional === true && schema.additionalProperties === undefined) {
             report.addError('KEYWORD_UNDEFINED_STRICT', ['additionalProperties'], undefined, schema, 'additionalProperties');
         }
-        // custome - assume defined false mode
+        // custom - assume defined false mode
         if (this.options.assumeAdditional && schema.additionalProperties === undefined) {
             schema.additionalProperties = false;
         }
@@ -256,9 +252,8 @@ const SchemaValidators = {
         }
         // Use shared regex compilation helper
         const keys = Object.keys(schema.patternProperties);
-        let idx = keys.length;
-        while (idx--) {
-            const key = keys[idx], val = schema.patternProperties[key];
+        for (const key of keys) {
+            const val = schema.patternProperties[key];
             const result = compileSchemaRegex(key);
             if (!result.ok) {
                 report.addError('KEYWORD_PATTERN', ['patternProperties', key, result.error.message], undefined, schema, 'patternProperties');
@@ -281,9 +276,7 @@ const SchemaValidators = {
         }
         else {
             const keys = Object.keys(schema.dependencies);
-            let idx = keys.length;
-            while (idx--) {
-                const schemaKey = keys[idx];
+            for (const schemaKey of keys) {
                 const schemaDependency = schema.dependencies[schemaKey];
                 const isSchemaDependency = isObject(schemaDependency) ||
                     (report.options.version !== 'draft-04' && typeof schemaDependency === 'boolean');
@@ -296,12 +289,11 @@ const SchemaValidators = {
                 }
                 else if (Array.isArray(schemaDependency)) {
                     const depArray = schemaDependency;
-                    let idx2 = depArray.length;
-                    if (report.options.version === 'draft-04' && idx2 === 0) {
+                    if (report.options.version === 'draft-04' && depArray.length === 0) {
                         report.addError('KEYWORD_MUST_BE', ['dependencies', 'not empty array'], undefined, schema, 'dependencies');
                     }
-                    while (idx2--) {
-                        if (typeof depArray[idx2] !== 'string') {
+                    for (const dep of depArray) {
+                        if (typeof dep !== 'string') {
                             report.addError('KEYWORD_VALUE_TYPE', ['dependencies', 'string'], undefined, schema, 'dependencies');
                         }
                     }
@@ -333,9 +325,8 @@ const SchemaValidators = {
         const primitiveTypeStr = primitiveTypes.join(',');
         const isArray = Array.isArray(schema.type);
         if (Array.isArray(schema.type)) {
-            let idx = schema.type.length;
-            while (idx--) {
-                if (primitiveTypes.indexOf(schema.type[idx]) === -1) {
+            for (const typeItem of schema.type) {
+                if (!primitiveTypes.includes(typeItem)) {
                     report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr], undefined, schema, 'type');
                 }
             }
@@ -344,7 +335,7 @@ const SchemaValidators = {
             }
         }
         else if (typeof schema.type === 'string') {
-            if (primitiveTypes.indexOf(schema.type) === -1) {
+            if (!primitiveTypes.includes(schema.type)) {
                 report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr], undefined, schema, 'type');
             }
         }
@@ -352,49 +343,49 @@ const SchemaValidators = {
             report.addError('KEYWORD_TYPE_EXPECTED', ['type', ['string', 'array']], undefined, schema, 'type');
         }
         if (this.options.noEmptyStrings === true) {
-            if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+            if (schema.type === 'string' || (isArray && schema.type.includes('string'))) {
                 if (schema.minLength === undefined && schema.enum === undefined && schema.format === undefined) {
                     schema.minLength = 1;
                 }
             }
         }
         if (this.options.noEmptyArrays === true) {
-            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+            if (schema.type === 'array' || (isArray && schema.type.includes('array'))) {
                 if (schema.minItems === undefined) {
                     schema.minItems = 1;
                 }
             }
         }
         if (this.options.forceProperties === true) {
-            if (schema.type === 'object' || (isArray && schema.type.indexOf('object') !== -1)) {
+            if (schema.type === 'object' || (isArray && schema.type.includes('object'))) {
                 if (schema.properties === undefined && schema.patternProperties === undefined) {
                     report.addError('KEYWORD_UNDEFINED_STRICT', ['properties'], undefined, schema, 'properties');
                 }
             }
         }
         if (this.options.forceItems === true) {
-            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+            if (schema.type === 'array' || (isArray && schema.type.includes('array'))) {
                 if (schema.items === undefined) {
                     report.addError('KEYWORD_UNDEFINED_STRICT', ['items'], undefined, schema, 'items');
                 }
             }
         }
         if (this.options.forceMinItems === true) {
-            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+            if (schema.type === 'array' || (isArray && schema.type.includes('array'))) {
                 if (schema.minItems === undefined) {
                     report.addError('KEYWORD_UNDEFINED_STRICT', ['minItems'], undefined, schema, 'minItems');
                 }
             }
         }
         if (this.options.forceMaxItems === true) {
-            if (schema.type === 'array' || (isArray && schema.type.indexOf('array') !== -1)) {
+            if (schema.type === 'array' || (isArray && schema.type.includes('array'))) {
                 if (schema.maxItems === undefined) {
                     report.addError('KEYWORD_UNDEFINED_STRICT', ['maxItems'], undefined, schema, 'maxItems');
                 }
             }
         }
         if (this.options.forceMinLength === true) {
-            if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+            if (schema.type === 'string' || (isArray && schema.type.includes('string'))) {
                 if (schema.minLength === undefined &&
                     schema.format === undefined &&
                     schema.enum === undefined &&
@@ -404,7 +395,7 @@ const SchemaValidators = {
             }
         }
         if (this.options.forceMaxLength === true) {
-            if (schema.type === 'string' || (isArray && schema.type.indexOf('string') !== -1)) {
+            if (schema.type === 'string' || (isArray && schema.type.includes('string'))) {
                 if (schema.maxLength === undefined &&
                     schema.format === undefined &&
                     schema.enum === undefined &&
@@ -423,8 +414,7 @@ const SchemaValidators = {
             report.addError('KEYWORD_MUST_BE', ['allOf', 'an array with at least one element'], undefined, schema, 'allOf');
         }
         else {
-            let idx = schema.allOf.length;
-            while (idx--) {
+            for (let idx = 0; idx < schema.allOf.length; idx++) {
                 report.path.push('allOf');
                 report.path.push(idx);
                 this.validateSchema(report, schema.allOf[idx]);
@@ -442,8 +432,7 @@ const SchemaValidators = {
             report.addError('KEYWORD_MUST_BE', ['anyOf', 'an array with at least one element'], undefined, schema, 'anyOf');
         }
         else {
-            let idx = schema.anyOf.length;
-            while (idx--) {
+            for (let idx = 0; idx < schema.anyOf.length; idx++) {
                 report.path.push('anyOf');
                 report.path.push(idx);
                 this.validateSchema(report, schema.anyOf[idx]);
@@ -461,8 +450,7 @@ const SchemaValidators = {
             report.addError('KEYWORD_MUST_BE', ['oneOf', 'an array with at least one element'], undefined, schema, 'oneOf');
         }
         else {
-            let idx = schema.oneOf.length;
-            while (idx--) {
+            for (let idx = 0; idx < schema.oneOf.length; idx++) {
                 report.path.push('oneOf');
                 report.path.push(idx);
                 this.validateSchema(report, schema.oneOf[idx]);
@@ -486,6 +474,48 @@ const SchemaValidators = {
             report.path.pop();
         }
     },
+    if: function (report, schema) {
+        if (report.options.version !== 'draft-07') {
+            return;
+        }
+        const ifSchema = schema.if;
+        const isValidIfSchema = typeof ifSchema === 'boolean' || isObject(ifSchema);
+        if (!isValidIfSchema) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['if', ['boolean', 'object']], undefined, schema, 'if');
+            return;
+        }
+        report.path.push('if');
+        this.validateSchema(report, ifSchema);
+        report.path.pop();
+    },
+    then: function (report, schema) {
+        if (report.options.version !== 'draft-07') {
+            return;
+        }
+        const thenSchema = schema.then;
+        const isValidThenSchema = typeof thenSchema === 'boolean' || isObject(thenSchema);
+        if (!isValidThenSchema) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['then', ['boolean', 'object']], undefined, schema, 'then');
+            return;
+        }
+        report.path.push('then');
+        this.validateSchema(report, thenSchema);
+        report.path.pop();
+    },
+    else: function (report, schema) {
+        if (report.options.version !== 'draft-07') {
+            return;
+        }
+        const elseSchema = schema.else;
+        const isValidElseSchema = typeof elseSchema === 'boolean' || isObject(elseSchema);
+        if (!isValidElseSchema) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['else', ['boolean', 'object']], undefined, schema, 'else');
+            return;
+        }
+        report.path.push('else');
+        this.validateSchema(report, elseSchema);
+        report.path.pop();
+    },
     definitions: function (report, schema) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.1
         if (!isObject(schema.definitions)) {
@@ -493,9 +523,8 @@ const SchemaValidators = {
         }
         else {
             const keys = Object.keys(schema.definitions);
-            let idx = keys.length;
-            while (idx--) {
-                const key = keys[idx], val = schema.definitions[key];
+            for (const key of keys) {
+                const val = schema.definitions[key];
                 report.path.push('definitions');
                 report.path.push(key);
                 this.validateSchema(report, val);
@@ -504,16 +533,56 @@ const SchemaValidators = {
             }
         }
     },
+    $defs: function (report, schema) {
+        if (report.options.version !== 'draft2019-09' && report.options.version !== 'draft2020-12') {
+            return;
+        }
+        if (!isObject(schema.$defs)) {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['$defs', 'object'], undefined, schema, '$defs');
+            return;
+        }
+        const keys = Object.keys(schema.$defs);
+        for (const key of keys) {
+            const val = schema.$defs[key];
+            report.path.push('$defs');
+            report.path.push(key);
+            this.validateSchema(report, val);
+            report.path.pop();
+            report.path.pop();
+        }
+    },
     format: function (report, schema) {
+        if (this.options.formatAssertions === false) {
+            return;
+        }
         if (typeof schema.format !== 'string') {
             report.addError('KEYWORD_TYPE_EXPECTED', ['format', 'string'], undefined, schema, 'format');
         }
         else {
-            if (!isFormatSupported(schema.format, this.options.customFormats) && this.options.ignoreUnknownFormats !== true) {
+            const isModernDraft = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+            if (!isFormatSupported(schema.format, this.options.customFormats) &&
+                this.options.ignoreUnknownFormats !== true &&
+                !isModernDraft) {
                 report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema, 'format');
             }
         }
     },
+    contentEncoding: function (report, schema) {
+        if (report.options.version !== 'draft-07') {
+            return;
+        }
+        if (typeof schema.contentEncoding !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['contentEncoding', 'string'], undefined, schema, 'contentEncoding');
+        }
+    },
+    contentMediaType: function (report, schema) {
+        if (report.options.version !== 'draft-07') {
+            return;
+        }
+        if (typeof schema.contentMediaType !== 'string') {
+            report.addError('KEYWORD_TYPE_EXPECTED', ['contentMediaType', 'string'], undefined, schema, 'contentMediaType');
+        }
+    },
     id: function (report, schema) {
         // http://json-schema.org/latest/json-schema-core.html#rfc.section.7.2
         if (typeof schema.id !== 'string') {
@@ -546,9 +615,8 @@ export class SchemaValidator {
         return this.validator.options;
     }
     validateArrayOfSchemas(report, arr) {
-        let idx = arr.length;
-        while (idx--) {
-            this.validateSchema(report, arr[idx]);
+        for (const schema of arr) {
+            this.validateSchema(report, schema);
         }
         return report.isValid();
     }
@@ -611,13 +679,11 @@ export class SchemaValidator {
             }
         }
         const keys = Object.keys(schema);
-        let idx = keys.length;
-        while (idx--) {
-            const key = keys[idx];
-            if (key.indexOf('__') === 0) {
+        for (const key of keys) {
+            if (key.startsWith('__')) {
                 continue;
             }
-            if (Object.prototype.hasOwnProperty.call(SchemaValidators, key)) {
+            if (Object.hasOwn(SchemaValidators, key)) {
                 SchemaValidators[key].call(this, report, schema);
             }
             else if (!hasParentSchema) {
@@ -633,8 +699,7 @@ export class SchemaValidator {
                 delete tmpSchema.enum;
                 delete tmpSchema.default;
                 report.path.push('enum');
-                idx = schema.enum.length;
-                while (idx--) {
+                for (let idx = 0; idx < schema.enum.length; idx++) {
                     report.path.push(idx);
                     validate.call(this.validator, report, tmpSchema, schema.enum[idx]);
                     report.path.pop();

package/dist/schemas/draft-07-schema.json

@@ -0,0 +1,172 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": true
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true,
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "if": { "$ref": "#" },
+        "then": { "$ref": "#" },
+        "else": { "$ref": "#" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": true
+}

package/dist/schemas/draft-2019-09-meta-applicator.json

@@ -0,0 +1,52 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
+    "$recursiveAnchor": true,
+    "title": "Applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "additionalItems": { "$recursiveRef": "#" },
+        "unevaluatedItems": { "$recursiveRef": "#" },
+        "items": {
+            "anyOf": [
+                { "$recursiveRef": "#" },
+                { "$ref": "#/$defs/schemaArray" }
+            ]
+        },
+        "contains": { "$recursiveRef": "#" },
+        "additionalProperties": { "$recursiveRef": "#" },
+        "unevaluatedProperties": { "$recursiveRef": "#" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": {
+                "$recursiveRef": "#"
+            }
+        },
+        "propertyNames": { "$recursiveRef": "#" },
+        "if": { "$recursiveRef": "#" },
+        "then": { "$recursiveRef": "#" },
+        "else": { "$recursiveRef": "#" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$recursiveRef": "#" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$recursiveRef": "#" }
+        }
+    }
+}

package/dist/schemas/draft-2019-09-meta-content.json

@@ -0,0 +1,12 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/content",
+    "$recursiveAnchor": true,
+    "title": "Content vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "contentSchema": { "$recursiveRef": "#" }
+    }
+}

package/dist/schemas/draft-2019-09-meta-core.json

@@ -0,0 +1,53 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/core",
+    "$recursiveAnchor": true,
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$anchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveRef": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveAnchor": {
+            "type": "boolean",
+            "default": false
+        },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": {
+                "type": "string",
+                "format": "uri"
+            },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        }
+    }
+}

package/dist/schemas/draft-2019-09-meta-format.json

@@ -0,0 +1,10 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/format",
+    "$recursiveAnchor": true,
+    "title": "Format vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}