json-schema-library 11.0.0 → 11.0.2

package/src/methods/getData.test.ts

@@ -2,1785 +2,1783 @@ import { compileSchema } from "../compileSchema";
 import { strict as assert } from "assert";
 
 describe("getData", () => {
-	it("should not modify input schema", () => {
-		const schema = {
-			type: "object",
-			properties: {
-				title: { type: "string", default: "title" },
-				list: {
-					type: "array",
-					items: { allOf: [{ type: "object" }, { properties: { index: { type: "number", default: 4 } } }] }
-				},
-				author: {
-					anyOf: [
-						{ type: "string", default: "jane" },
-						{ type: "string", default: "john" }
-					]
-				},
-				source: { type: "string", enum: ["dpa", "getty"] }
-			}
-		};
-		const originalSchema = JSON.stringify(schema);
-		const node = compileSchema(schema);
-		node.getData({});
-		assert.deepEqual(JSON.stringify(schema), originalSchema);
-	});
-
-	describe("values", () => {
-		it("should return default value missing input and type", () => {
-			const data = compileSchema({ default: 123 }).getData();
-			assert.deepEqual(data, 123);
-		});
-
-		it("should NOT override input value for missing type", () => {
-			const data = compileSchema({ default: 123 }).getData("input");
-			assert.deepEqual(data, "input");
-		});
-
-		// @attention, changing input data
-		it("should alwayys return const value", () => {
-			const data = compileSchema({ const: "const", default: 123 }).getData(123);
-			assert.deepEqual(data, "const");
-		});
-
-		it("should prefer const over default", () => {
-			const data = compileSchema({
-				type: "string",
-				const: "static",
-				default: "should be overwritten"
-			}).getData();
-			assert.deepEqual(data, "static");
-		});
-
-		describe("string", () => {
-			it("should return empty string for missing default value", () => {
-				const data = compileSchema({ type: "string" }).getData();
-				assert.deepEqual(data, "");
-			});
-
-			it("should return default value", () => {
-				const data = compileSchema({
-					type: "string",
-					default: "default"
-				}).getData();
-				assert.deepEqual(data, "default");
-			});
-
-			it("should return string data", () => {
-				const data = compileSchema({
-					type: "string",
-					default: "default"
-				}).getData("input");
-				assert.deepEqual(data, "input");
-			});
-		});
-
-		describe("number", () => {
-			it("should return 0 for missing default value", () => {
-				const data = compileSchema({ type: "number" }).getData();
-				assert.deepEqual(data, 0);
-			});
-
-			it("should return default value", () => {
-				const data = compileSchema({ type: "number", default: 99 }).getData();
-				assert.deepEqual(data, 99);
-			});
-
-			it("should return number data", () => {
-				const data = compileSchema({ type: "number", default: 99 }).getData(123);
-				assert.deepEqual(data, 123);
-			});
-		});
-
-		describe("integer", () => {});
-
-		describe("boolean", () => {
-			it("should return `false` for missing default value", () => {
-				const data = compileSchema({ type: "boolean", default: false }).getData();
-				assert.deepEqual(data, false);
-			});
-
-			it("should return default value of boolean", () => {
-				const data = compileSchema({ type: "boolean", default: false }).getData();
-				assert.deepEqual(data, false);
-			});
-
-			it("should not override given boolean if it is `false`", () => {
-				const data = compileSchema({ type: "boolean", default: true }).getData(false);
-				assert.deepEqual(data, false);
-			});
-
-			it("should not override given boolean if it is `true`", () => {
-				const data = compileSchema({ type: "boolean", default: false }).getData(true);
-				assert.deepEqual(data, true);
-			});
-		});
-
-		describe("null", () => {
-			it("should return `null` for missing default value", () => {
-				const data = compileSchema({ type: "null" }).getData();
-				assert.deepEqual(data, null);
-			});
-
-			it("should return `null` when first type in type-array", () => {
-				const node = compileSchema({ type: ["null", "string"] });
-				const res = node.getData();
-
-				assert.deepEqual(res, null);
-			});
-
-			it("should return default value of null", () => {
-				const data = compileSchema({ type: "null", default: null }).getData();
-				assert.deepEqual(data, null);
-			});
-
-			it("should return default value of null even for wrong typye", () => {
-				const data = compileSchema({ type: "number", default: null }).getData();
-				assert.deepEqual(data, null);
-			});
-
-			it("should support `null` type properties", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["nullType"],
-					properties: { nullType: { type: "null" } }
-				}).getData();
-				assert.deepEqual(data, { nullType: null });
-			});
-
-			it("should return `null` input for strings", () => {
-				const data = compileSchema({ type: "string" }).getData(null);
-				assert.deepEqual(data, null);
-			});
-
-			it("should return `null` input for value-property", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["title"],
-					properties: { title: { type: "number" } }
-				}).getData({ title: null });
-				assert.deepEqual(data, { title: null });
-			});
-		});
-
-		describe("enum", () => {
-			it("should set the first enum option for a missing default", () => {
-				const data = compileSchema({ enum: ["first", "second"] }).getData();
-				assert.deepEqual(data, "first");
-			});
-
-			it("should use default value in any case", () => {
-				const data = compileSchema({ enum: ["first", "second"], default: "" }).getData();
-				assert.deepEqual(data, "");
-			});
-		});
-
-		describe("file", () => {
-			it("should not modify file-instance", () => {
-				const file = new File([], "testfile.pdf");
-				const data = compileSchema({
-					type: ["string", "object"],
-					format: "file"
-				}).getData(file);
-				assert.deepEqual(data, file);
-			});
-
-			it("should not modify file-instance on object", () => {
-				const file = new File([], "testfile.pdf");
-				const data = compileSchema({
-					type: "object",
-					properties: { file: { type: ["string", "object"], format: "file" } }
-				}).getData({ file });
-				assert.deepEqual(data, { file });
-			});
-		});
-
-		describe("oneOf", () => {
-			it("should return first schema for mixed types", () => {
-				const node = compileSchema({
-					oneOf: [{ type: "string", default: "jane" }, { type: "number" }]
-				});
-				const res = node.getData();
-
-				assert.deepEqual(res, "jane");
-			});
-		});
-	});
-
-	describe("object", () => {
-		describe("behaviour", () => {
-			it("should return {} for a missing default value", () => {
-				const data = compileSchema({ type: "object" }).getData();
-				assert.deepEqual(data, {});
-			});
-
-			it("should return default value of object", () => {
-				const data = compileSchema({
-					type: "object",
-					default: { init: true }
-				}).getData();
-				assert.deepEqual(data, { init: true });
-			});
-
-			it("should return input data", () => {
-				const data = compileSchema({ type: "object" }).getData({ init: false });
-				assert.deepEqual(data, { init: false });
-			});
-
-			it("should override default by input data", () => {
-				const data = compileSchema({
-					type: "object",
-					default: { init: true }
-				}).getData({ init: false });
-				assert.deepEqual(data, { init: false });
-			});
-		});
-
-		describe("properties", () => {
-			it("should return default object", () => {
-				const data = compileSchema({
-					type: "object",
-					properties: { first: { type: "string" }, second: { type: "number" } },
-					default: { first: "john", second: 4 }
-				}).getData();
-				assert.deepEqual(data, { first: "john", second: 4 });
-			});
-
-			it("should return only required object properties", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first"],
-					properties: { first: { type: "string" }, second: { type: "number" } }
-				}).getData();
-				assert.deepEqual(data, { first: "" });
-			});
-
-			it("should not fail on falsy input data", () => {
-				const data = compileSchema({
-					type: "object",
-					properties: {
-						first: { type: "boolean", default: true },
-						second: { type: "boolean", default: false }
-					}
-				}).getData({ first: false, second: true });
-				assert.deepEqual(data, { first: false, second: true });
-			});
-
-			it("should return all object properties with `addOptionalProps=true`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" }, second: { type: "number" } }
-				}).getData({}, { addOptionalProps: true });
-				assert.deepEqual(data, { first: "", second: 0 });
-			});
-
-			it("should NOT override given default values by other default values", () => {
-				const data = compileSchema({
-					type: "object",
-					properties: { first: { type: "string", default: "jane" }, second: { type: "number" } },
-					default: { first: "john", second: 4 }
-				}).getData();
-				assert.deepEqual(data, { first: "john", second: 4 });
-			});
-
-			it("should extend given template data by property default values", () => {
-				const data = compileSchema({
-					type: "object",
-					properties: { first: { type: "string", default: "jane" }, second: { type: "number" } },
-					default: { first: "john", second: 4 }
-				}).getData({ second: 8 });
-				assert.deepEqual(data, { first: "john", second: 8 });
-			});
-		});
-
-		describe("additionalProperties & option: removeInvalidData", () => {
-			it("should NOT remove additional properties `additionalProperties=undefined`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" } }
-				}).getData({ first: "first", second: 42 });
-				assert.deepEqual(data, { first: "first", second: 42 });
-			});
-
-			it("should NOT remove additional properties `additionalProperties=true`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" } },
-					additionalProperties: true
-				}).getData({ first: "first", second: 42 });
-				assert.deepEqual(data, { first: "first", second: 42 });
-			});
-
-			it("should NOT remove non matching properties with `additionalProperties={schema}`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" } },
-					additionalProperties: { type: "string" }
-				}).getData({ first: "first", second: 42 });
-				assert.deepEqual(data, { first: "first", second: 42 });
-			});
-
-			it("should NOT remove additional properties with `additionalProperties=false`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" } },
-					additionalProperties: false
-				}).getData({ first: "first", second: 42 });
-				assert.deepEqual(data, { first: "first", second: 42 });
-			});
-
-			it("should remove unmatched properties with option `removeInvalidData=true`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" } },
-					additionalProperties: false
-				}).getData({ first: "first", second: 42, thrid: "third" }, { removeInvalidData: true });
-				assert.deepEqual(data, { first: "first" });
-			});
-
-			it("should remove invalid properties with option `removeInvalidData=true`", () => {
-				const data = compileSchema({
-					type: "object",
-					required: ["first", "second"],
-					properties: { first: { type: "string" } },
-					additionalProperties: { type: "number" }
-				}).getData({ first: "first", second: 42, third: "third", fourth: false }, { removeInvalidData: true });
-				assert.deepEqual(data, { first: "first", second: 42 });
-			});
-		});
-
-		// patternNames
-		// patternProperties
-		// dependentSchemas
-		// dependentRequired
-		// (unevaluatedPoperties)
-
-		describe("allOf", () => {
-			it("should create template for merged allOf schema", () => {
-				const data = compileSchema({
-					type: "object",
-					allOf: [
-						{
-							required: ["name"],
-							properties: { name: { type: "string", default: "jane" } }
-						},
-						{
-							required: ["stage"],
-							properties: { stage: { type: "string", default: "test" } }
-						}
-					]
-				}).getData({ name: "john" });
-				assert.deepEqual(data, { name: "john", stage: "test" });
-			});
-		});
-
-		describe("anyOf", () => {
-			it("should create template for first anyOf schema", () => {
-				const node = compileSchema({
-					type: "object",
-					anyOf: [
-						{
-							required: ["name", "stage"],
-							properties: {
-								name: { type: "string", default: "jane" },
-								stage: { type: "string", default: "develop" }
-							}
-						},
-						{
-							required: ["stage"],
-							properties: {
-								stage: { type: "number", default: 0 }
-							}
-						}
-					]
-				});
-				const res = node.getData({ name: "john" });
-
-				assert.deepEqual(res, { name: "john", stage: "develop" });
-			});
-		});
-
-		describe("oneOf", () => {
-			describe("oneOf", () => {
-				it("should return template of first oneOf schema", () => {
-					const node = compileSchema({
-						type: "object",
-						oneOf: [
-							{
-								type: "object",
-								required: ["title"],
-								properties: {
-									title: { type: "string", default: "jane" }
-								}
-							},
-							{
-								type: "object",
-								required: ["value"],
-								properties: { value: { type: "number" } }
-							}
-						]
-					});
-					const res = node.getData();
-
-					assert.deepEqual(res, { title: "jane" });
-				});
-
-				it("should extend empty object with first oneOf schema", () => {
-					const node = compileSchema({
-						type: "object",
-						oneOf: [
-							{
-								type: "object",
-								required: ["title"],
-								properties: {
-									title: { type: "string", default: "jane" }
-								}
-							},
-							{
-								type: "object",
-								required: ["value"],
-								properties: { value: { type: "number" } }
-							}
-						]
-					});
-					const res = node.getData({});
-
-					assert.deepEqual(res, { title: "jane" });
-				});
-
-				it("should return template of matching oneOf schema", () => {
-					const node = compileSchema({
-						type: "object",
-						oneOf: [
-							{
-								type: "object",
-								required: ["value"],
-								properties: {
-									value: { type: "string", default: "jane" }
-								}
-							},
-							{
-								type: "object",
-								required: ["value", "test"],
-								properties: {
-									value: { type: "number" },
-									test: { type: "string", default: "test" }
-								}
-							}
-						]
-					});
-					const res = node.getData({ value: 111 });
-
-					assert.deepEqual(res, { value: 111, test: "test" });
-				});
-
-				it("should return input value if no oneOf-schema matches ", () => {
-					const node = compileSchema({
-						type: "object",
-						oneOf: [
-							{
-								type: "object",
-								properties: {
-									value: { type: "string", default: "jane" }
-								}
-							},
-							{
-								type: "object",
-								properties: {
-									value: { type: "number" },
-									test: { type: "string", default: "test" }
-								}
-							}
-						]
-					});
-					const res = node.getData({ value: ["keep-me"] });
-
-					assert.deepEqual(res, { value: ["keep-me"] });
-				});
-
-				it("should not require object type definition in oneOf schemas", () => {
-					const node = compileSchema({
-						type: "object",
-						oneOf: [
-							{
-								required: ["type"],
-								properties: {
-									type: { const: "header" }
-								}
-							},
-							{
-								required: ["type"],
-								properties: {
-									type: { const: "paragraph" }
-								}
-							}
-						]
-					});
-
-					const res = node.getData({ type: "paragraph" });
-					assert.deepEqual(res, { type: "paragraph" });
-				});
-
-				it("should return valid default data", () => {
-					const node = compileSchema({
-						type: "object",
-						default: { value: 123 },
-						oneOf: [
-							{
-								type: "object",
-								required: ["title"],
-								properties: { title: { type: "string", default: "jane" } }
-							},
-							{ type: "object", required: ["value"], properties: { value: { type: "number" } } }
-						]
-					});
-					const res = node.getData();
-
-					assert.deepEqual(res, { value: 123 });
-				});
-
-				it("should return invalid default data", () => {
-					const node = compileSchema({
-						type: "object",
-						default: { value: "wrong type" },
-						oneOf: [
-							{
-								type: "object",
-								required: ["title"],
-								properties: { title: { type: "string", default: "jane" } }
-							},
-							{ type: "object", required: ["value"], properties: { value: { type: "number" } } }
-						]
-					});
-					const res = node.getData();
-
-					assert.deepEqual(res, { value: "wrong type" });
-				});
-
-				it("should add correct optional properties from schema matching default data", () => {
-					const node = compileSchema({
-						type: "object",
-						default: { value: 123 },
-						oneOf: [
-							{
-								type: "object",
-								required: ["title"],
-								properties: { title: { type: "string", default: "jane" } }
-							},
-							{
-								type: "object",
-								required: ["value"],
-								properties: { value: { type: "number" }, optional: { type: "string" } }
-							}
-						]
-					});
-					const res = node.getData(undefined, { addOptionalProps: true });
-
-					assert.deepEqual(res, { value: 123, optional: "" });
-				});
-			});
-		});
-	});
-
-	describe("array", () => {
-		describe("behaviour", () => {
-			it("should return [] for a missing default value", () => {
-				const data = compileSchema({ type: "array" }).getData();
-				assert.deepEqual(data, []);
-			});
-
-			it("should return default value of object", () => {
-				const data = compileSchema({ type: "array", default: [true] }).getData();
-				assert.deepEqual(data, [true]);
-			});
-
-			it("should return input data", () => {
-				const data = compileSchema({ type: "array" }).getData(["input"]);
-				assert.deepEqual(data, ["input"]);
-			});
-
-			it("should override default by input data", () => {
-				const data = compileSchema({
-					type: "array",
-					default: ["default"]
-				}).getData(["input"]);
-				assert.deepEqual(data, ["input"]);
-			});
-		});
-
-		describe("items: {}", () => {
-			it("should return empty array if minItems is undefined", () => {
-				const data = compileSchema({ items: { type: "boolean" } }).getData();
-				assert.deepEqual(data, []);
-			});
-
-			it("should return array with length of minItems", () => {
-				const data = compileSchema({
-					minItems: 3,
-					items: { type: "boolean" }
-				}).getData();
-				assert(Array.isArray(data));
-				assert.deepEqual(data.length, 3);
-				assert.deepEqual(data, [false, false, false]);
-			});
-
-			it("should return default array even if minItems is not set", () => {
-				const data = compileSchema({
-					default: ["a", "b"],
-					items: { type: "string" }
-				}).getData();
-				assert.deepEqual(data, ["a", "b"]);
-			});
-
-			it("should return default array if part of object", () => {
-				const data = compileSchema({
-					required: ["list"],
-					properties: { list: { type: "array", default: ["a", "b"], items: { type: "string" } } }
-				}).getData();
-				assert.deepEqual(data, { list: ["a", "b"] });
-			});
-
-			it("should not override given default values", () => {
-				const data = compileSchema({
-					minItems: 2,
-					default: ["abba", "doors"],
-					items: { type: "string", default: "elvis" }
-				}).getData();
-				assert.deepEqual(data, ["abba", "doors"]);
-			});
-
-			it("should extend given template data by default values", () => {
-				const data = compileSchema({
-					minItems: 2,
-					default: ["abba", "doors"],
-					items: { type: "string" }
-				}).getData(["elvis"]);
-				assert.deepEqual(data, ["elvis", "doors"]);
-			});
-
-			it("should extend all input objects by missing properties", () => {
-				const data = compileSchema({
-					default: ["abba", "doors"],
-					items: {
-						type: "object",
-						required: ["first", "second"],
-						properties: {
-							first: { type: "string", default: "first" },
-							second: { type: "string", default: "second" }
-						}
-					}
-				}).getData([{ first: "user input" }, {}]);
-				assert.deepEqual(data, [
-					{ first: "user input", second: "second" },
-					{ first: "first", second: "second" }
-				]);
-			});
-
-			it("should resolve $ref in items-object", () => {
-				const data = compileSchema({
-					minItems: 1,
-					items: { $ref: "/$defs/bool" },
-					$defs: {
-						bool: { type: "boolean", default: true }
-					}
-				}).getData();
-				assert(Array.isArray(data));
-				assert.deepEqual(data.length, 1);
-				assert.deepEqual(data, [true]);
-			});
-		});
-
-		describe("prefixItems: []", () => {
-			// - Tuple validation is useful when the array is a collection of items where each has a different schema
-			// and the ordinal index of each item is meaningful.
-			// - It’s ok to not provide all of the items:
-			// https://spacetelescope.github.io/understanding-json-schema/reference/array.html#tuple-validation
-			it("should return array with minItems in given order", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 2,
-					prefixItems: [{ type: "string" }, { type: "boolean" }]
-				}).getData();
-				assert.deepEqual(data, ["", false]);
-			});
-
-			it("should not override input items when complementing minItems", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 2,
-					prefixItems: [{ type: "boolean", default: false }, { type: "string" }]
-				}).getData([true]);
-				assert.deepEqual(data, [true, ""]);
-			});
-
-			it("should not override wrong input items", () => {
-				const data = compileSchema({
-					type: "array",
-					prefixItems: [
-						{ type: "boolean", default: false },
-						{ type: "string", default: "default" }
-					]
-				}).getData([42, false]);
-				assert.deepEqual(data, [42, "false"]);
-			});
-
-			it("should return default array", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 1,
-					default: [true],
-					items: {
-						type: "boolean"
-					}
-				}).getData();
-				assert.deepEqual(data, [true]);
-			});
-
-			it("should convert input data for strings", () => {
-				const node = compileSchema({
-					type: "array",
-					minItems: 1,
-					prefixItems: [{ type: "string" }]
-				});
-				const res = node.getData([43]);
-
-				assert.deepEqual(res, ["43"]);
-			});
-
-			it("should convert input data for numbers", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 1,
-					prefixItems: [{ type: "number" }]
-				}).getData(["43"]);
-				assert.deepEqual(data, [43]);
-			});
-
-			it("should convert input data for strings", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 1,
-					prefixItems: [{ type: "string" }]
-				}).getData([43]);
-				assert.deepEqual(data, ["43"]);
-			});
-
-			it("should NOT convert invalid number if we would lose data", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 1,
-					prefixItems: [{ type: "number" }]
-				}).getData(["asd"]);
-				assert.deepEqual(data, ["asd"]);
-			});
-
-			it("should convert input data for booleans", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 1,
-					prefixItems: [{ type: "boolean" }]
-				}).getData(["false"]);
-				assert.deepEqual(data, [false]);
-			});
-
-			it("should NOT convert invalid boolean if we would lose data", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 1,
-					prefixItems: [{ type: "boolean" }]
-				}).getData(["43"]);
-				assert.deepEqual(data, ["43"]);
-			});
-
-			it("should add defaults from `items`", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 2,
-					items: {
-						type: "number",
-						default: 2
-					}
-				}).getData([43]);
-				assert.deepEqual(data, [43, 2]);
-			});
-
-			it("should add defaults from `items` for items not in prefixItems", () => {
-				const data = compileSchema({
-					type: "array",
-					minItems: 2,
-					prefixItems: [{ type: "boolean" }],
-					items: { type: "number", default: 2 }
-				}).getData([43]);
-				assert.deepEqual(data, [43, 2]);
-			});
-
-			it("should add prefixItems with `addOptionalProps: true`", () => {
-				const data = compileSchema(
-					{
-						type: "array",
-						prefixItems: [{ type: "boolean", default: true }],
-						items: { type: "number", default: 2 }
-					},
-					{
-						getDataDefaultOptions: { addOptionalProps: true }
-					}
-				).getData();
-				assert.deepEqual(data, [true]);
-			});
-
-			it("should resolve $ref in prefixItems", () => {
-				const node = compileSchema({
-					type: "array",
-					minItems: 2,
-					prefixItems: [{ $ref: "/$defs/bool" }, { $ref: "/$defs/string" }],
-					$defs: {
-						bool: { type: "boolean" },
-						string: { type: "string" }
-					}
-				});
-				const res = node.getData([]);
-
-				assert.deepEqual(res, [false, ""]);
-			});
-		});
-
-		describe("oneOf", () => {
-			it("should return template of first oneOf schema", () => {
-				const node = compileSchema({
-					type: "array",
-					minItems: 1,
-					items: {
-						oneOf: [
-							{ type: "string", default: "target" },
-							{ type: "number", default: 9 }
-						]
-					}
-				});
-				const res = node.getData();
-
-				assert(Array.isArray(res));
-				assert.deepEqual(res.length, 1);
-				assert.deepEqual(res, ["target"]);
-			});
-
-			it("should merge with input data", () => {
-				const node = compileSchema({
-					type: "array",
-					minItems: 1,
-					items: {
-						oneOf: [
-							{
-								type: "object",
-								required: ["notitle"],
-								properties: {
-									notitle: {
-										type: "string",
-										default: "nottitle"
-									}
-								}
-							},
-							{
-								type: "object",
-								required: ["title", "subtitle"],
-								properties: {
-									title: {
-										type: "string",
-										default: "Standardtitel"
-									},
-									subtitle: {
-										type: "string",
-										default: "do not replace with"
-									}
-								}
-							},
-							{ type: "number", default: 9 }
-						]
-					}
-				});
-
-				const res = node.getData([{ subtitle: "Subtitel" }]);
-
-				assert(Array.isArray(res));
-				assert.deepEqual(res.length, 1);
-				assert.deepEqual(res, [{ title: "Standardtitel", subtitle: "Subtitel" }]);
-			});
-
-			it("should not remove invalid oneOf schema if 'removeInvalidData' is unset", () => {
-				const node = compileSchema({
-					type: "object",
-					properties: {
-						filter: {
-							$ref: "#/definitions/filter"
-						}
-					},
-					definitions: {
-						filter: {
-							type: "array",
-							items: {
-								oneOf: [
-									{
-										type: "object",
-										properties: {
-											op: {
-												const: "in"
-											},
-											property: { type: "string", minLength: 1 }
-										}
-									}
-								]
-							}
-						}
-					}
-				});
-				const res = node.getData({ filter: [{ op: "möp" }] });
-				assert.deepEqual(res, { filter: [{ op: "möp" }] });
-			});
-		});
-
-		describe("allOf", () => {
-			it("should create template for merged allOf schema", () => {
-				const node = compileSchema({
-					type: "array",
-					minItems: 2,
-					items: {
-						type: "object",
-						allOf: [
-							{
-								required: ["title"],
-								properties: {
-									title: { type: "string", default: "title" }
-								}
-							},
-							{
-								required: ["caption"],
-								properties: {
-									caption: {
-										type: "string",
-										default: "caption"
-									}
-								}
-							}
-						]
-					}
-				});
-
-				const res = node.getData([{ title: "given-title" }]);
-				assert.deepEqual(res, [
-					{ title: "given-title", caption: "caption" },
-					{ title: "title", caption: "caption" }
-				]);
-			});
-		});
-
-		describe("anyOf", () => {
-			it("should create template for first anyOf schema", () => {
-				const node = compileSchema({
-					type: "array",
-					minItems: 2,
-					items: {
-						type: "object",
-						anyOf: [
-							{
-								required: ["title"],
-								properties: {
-									title: { type: "string", default: "title" }
-								}
-							},
-							{
-								required: ["properties"],
-								properties: {
-									caption: {
-										type: "string",
-										default: "caption"
-									}
-								}
-							}
-						]
-					}
-				});
-
-				const res = node.getData([{ title: "given-title" }]);
-				assert.deepEqual(res, [{ title: "given-title" }, { title: "title" }]);
-			});
-		});
-
-		// draft07 (backwards compatible)
-		describe("dependencies", () => {
-			describe("option: `additionalProps: false`", () => {
-				const TEMPLATE_OPTIONS = { addOptionalProps: false };
-				describe("dependency required", () => {
-					it("should not add dependency if it is not required", () => {
-						const node = compileSchema({
-							type: "object",
-							properties: {
-								trigger: { type: "string" },
-								dependency: { type: "string", default: "default" }
-							},
-							dependencies: {
-								trigger: ["dependency"]
-							}
-						});
-
-						const res = node.getData({}, TEMPLATE_OPTIONS);
-						assert.deepEqual(res, {});
-					});
-
-					it("should add dependency if triggered as required", () => {
-						const node = compileSchema({
-							type: "object",
-							properties: {
-								trigger: { type: "string" },
-								dependency: { type: "string", default: "default" }
-							},
-							dependencies: {
-								trigger: ["dependency"]
-							}
-						});
-
-						const res = node.getData({ trigger: "yes" }, TEMPLATE_OPTIONS);
-						assert.deepEqual(res, { trigger: "yes", dependency: "default" });
-					});
-
-					it("should add dependency if initially triggered as required", () => {
-						const node = compileSchema({
-							type: "object",
-							required: ["trigger"],
-							properties: {
-								trigger: { type: "string" },
-								dependency: { type: "string", default: "default" }
-							},
-							dependencies: {
-								trigger: ["dependency"]
-							}
-						});
-
-						const res = node.getData({}, TEMPLATE_OPTIONS);
-						assert.deepEqual(res, { trigger: "", dependency: "default" });
-					});
-				});
-
-				describe("dependency schema", () => {
-					it("should not add dependency from schema if it is not required", () => {
-						const node = compileSchema({
-							type: "object",
-							properties: {
-								trigger: { type: "string" }
-							},
-							dependencies: {
-								trigger: {
-									properties: {
-										dependency: { type: "string", default: "default" }
-									}
-								}
-							}
-						});
-
-						const res = node.getData({}, TEMPLATE_OPTIONS);
-						assert.deepEqual(res, {});
-					});
-
-					it("should add dependency from schema if triggered as required", () => {
-						const node = compileSchema({
-							type: "object",
-							properties: {
-								trigger: { type: "string" }
-							},
-							dependencies: {
-								trigger: {
-									required: ["dependency"],
-									properties: {
-										dependency: { type: "string", default: "default" }
-									}
-								}
-							}
-						});
-
-						const res = node.getData({ trigger: "yes" }, TEMPLATE_OPTIONS);
-						assert.deepEqual(res, { trigger: "yes", dependency: "default" });
-					});
-				});
-			});
-
-			describe("option: `additionalProps: true`", () => {
-				it("should create template for valid dependency", () => {
-					const node = compileSchema({
-						type: "object",
-						properties: {
-							test: { type: "string", default: "tested value" }
-						},
-						dependencies: {
-							test: {
-								properties: {
-									additionalValue: { type: "string", default: "additional" }
-								}
-							}
-						}
-					});
-					const res = node.getData(undefined, {
-						addOptionalProps: true
-					});
-					assert.deepEqual(res, {
-						test: "tested value",
-						additionalValue: "additional"
-					});
-				});
-
-				it("should not change passed value of dependency", () => {
-					const node = compileSchema({
-						type: "object",
-						properties: {
-							test: { type: "string", default: "tested value" }
-						},
-						dependencies: {
-							test: {
-								properties: {
-									additionalValue: { type: "string", default: "additional" }
-								}
-							}
-						}
-					});
-					const res = node.getData(
-						{ additionalValue: "input value" },
-						{
-							addOptionalProps: true
-						}
-					);
-					assert.deepEqual(res, {
-						test: "tested value",
-						additionalValue: "input value"
-					});
-				});
-
-				it("should not create data for non matching dependency", () => {
-					const node = compileSchema({
-						type: "object",
-						properties: {
-							test: { type: "string", default: "tested value" }
-						},
-						dependencies: {
-							unknown: {
-								properties: {
-									additionalValue: { type: "string", default: "additional" }
-								}
-							}
-						}
-					});
-					const res = node.getData(undefined, {
-						addOptionalProps: true
-					});
-					assert.deepEqual(res, { test: "tested value" });
-				});
-			});
-		});
-	});
-
-	describe("$ref", () => {
-		it("should return default value of resolved ref", () => {
-			const data = compileSchema({
-				$ref: "#/$defs/once",
-				$defs: { once: { default: "once" } }
-			}).getData();
-			assert.deepEqual(data, "once");
-		});
-
-		it("should follow all refs", () => {
-			const data = compileSchema({
-				$ref: "#/$defs/once",
-				$defs: { once: { $ref: "#/$defs/twice" }, twice: { default: "twice" } }
-			}).getData();
-			assert.deepEqual(data, "twice");
-		});
-
-		it("should resolve $ref in object schema", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["first"],
-				properties: { first: { $ref: "#/definitions/first" } },
-				definitions: { first: { type: "string", default: "john" } }
-			}).getData();
-			assert.deepEqual(data, { first: "john" });
-		});
-
-		it("should create template for all followed refs (draft 2019-09)", () => {
-			const data = compileSchema({
-				$ref: "#/$defs/once",
-				$defs: {
-					once: { required: ["once"], properties: { once: { type: "number" } }, $ref: "#/$defs/twice" },
-					twice: { required: ["twice"], properties: { twice: { type: "boolean", default: true } } }
-				}
-			}).getData();
-			assert.deepEqual(data, { once: 0, twice: true });
-		});
-
-		it("should resolve $ref in items-array", () => {
-			const data = compileSchema({
-				type: "array",
-				prefixItems: [{ $ref: "#/definitions/first" }],
-				definitions: {
-					first: {
-						type: "object",
-						required: ["first"],
-						properties: { first: { type: "string", default: "john" } }
-					}
-				}
-			}).getData([{}, {}]);
-			assert.deepEqual(data, [{ first: "john" }, {}]);
-		});
-
-		it("should follow $ref once", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["value", "nodes"],
-				properties: {
-					value: { type: "string", default: "node" },
-					nodes: { type: "array", minItems: 1, items: { $ref: "#" } }
-				}
-			}).getData({}, { recursionLimit: 1 });
-			assert.deepEqual(data, { value: "node", nodes: [{ value: "node", nodes: [] }] });
-		});
-
-		it("should resolve all reoccuring refs ", () => {
-			const data = compileSchema({
-				minItems: 3,
-				items: {
-					$ref: "#/$defs/item"
-				},
-				$defs: {
-					item: {
-						required: ["type"],
-						properties: {
-							type: {
-								const: "node"
-								// $ref: "#"
-							}
-						}
-					}
-				}
-			}).getData([], { recursionLimit: 1 });
-			assert.deepEqual(data, [{ type: "node" }, { type: "node" }, { type: "node" }]);
-		});
-
-		// iteration depth is 1, input-depth is 2 => still add template to depth 2
-		it("should respect depth of input data in $ref-resolution", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["value", "nodes"],
-				properties: {
-					value: { type: "string", default: "node" },
-					nodes: { type: "array", minItems: 1, items: { $ref: "#" } }
-				}
-			}).getData(
-				{ nodes: [{ value: "input-node" }, { nodes: [{ nodes: [] }] }] },
-				{
-					recursionLimit: 1
-				}
-			);
-
-			assert.deepEqual(data, {
-				value: "node",
-				nodes: [
-					{
-						value: "input-node",
-						nodes: []
-					},
-					{
-						value: "node",
-						nodes: [
-							{
-								value: "node",
-								nodes: []
-							}
-						]
-					}
-				]
-			});
-		});
-
-		it("should create template of draft04", () => {
-			const schema = require("../../remotes/draft04.json");
-			const node = compileSchema({ ...schema, $schema: "draft-06" });
-			const res = node.getData({}, { addOptionalProps: true });
-			// console.log("RESULT\n", JSON.stringify(res, null, 2));
-			assert.deepEqual(Object.prototype.toString.call(res), "[object Object]");
-		});
-
-		it("should create template of draft07", () => {
-			const data = compileSchema(require("../../remotes/draft07.json")).getData({}, { addOptionalProps: true });
-			// console.log("RESULT\n", JSON.stringify(data, null, 2));
-			assert.deepEqual(Object.prototype.toString.call(data), "[object Object]");
-		});
-	});
-
-	describe("if-then-else", () => {
-		it("should return template of then-schema for valid if-schema", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["test"],
-				properties: { test: { type: "string", default: "with value" } },
-				if: { properties: { test: { type: "string", minLength: 4 } } },
-				then: { required: ["dynamic"], properties: { dynamic: { type: "string", default: "from then" } } }
-			}).getData();
-			assert.deepEqual(data, {
-				test: "with value",
-				dynamic: "from then"
-			});
-		});
-
-		it("should NOT create data for then-schema if it is not required", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["test"],
-				properties: { test: { type: "string", default: "with value" } },
-				if: { properties: { test: { type: "string", minLength: 4 } } },
-				then: { properties: { dynamic: { type: "string", default: "from then" } } }
-			}).getData(undefined, { addOptionalProps: false });
-			assert.deepEqual(data, { test: "with value" });
-		});
-
-		it("should NOT return template of then-schema for invalid if-schema", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["test"],
-				properties: { test: { type: "string", default: "too short" } },
-				if: { properties: { test: { type: "string", minLength: 40 } } },
-				then: { properties: { dynamic: { type: "string", default: "from then" } } }
-			}).getData();
-			assert.deepEqual(data, { test: "too short" });
-		});
-
-		it("should return template of else-schema for invalid if-schema", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["test"],
-				properties: { test: { type: "string", default: "with test" } },
-				if: { properties: { test: { type: "string", minLength: 40 } } },
-				then: { required: ["dynamic"], properties: { dynamic: { type: "string", default: "from then" } } },
-				else: { required: ["dynamic"], properties: { dynamic: { type: "string", default: "from else" } } }
-			}).getData();
-			assert.deepEqual(data, { test: "with test", dynamic: "from else" });
-		});
-
-		it("should incrementally resolve multiple 'then'-schema", () => {
-			const data = compileSchema({
-				type: "object",
-				required: ["trigger"],
-				properties: { trigger: { type: "boolean" } },
-				allOf: [
-					{
-						if: { properties: { trigger: { const: true } } },
-						then: {
-							required: ["additionalSchema"],
-							properties: { additionalSchema: { type: "string", default: "additional" } }
-						}
-					},
-					{
-						if: { required: ["additionalSchema"], properties: { additionalSchema: { minLength: 5 } } },
-						then: {
-							required: ["anotherSchema"],
-							properties: { anotherSchema: { type: "string", default: "another" } }
-						}
-					}
-				]
-			}).getData({ trigger: true });
-			assert.deepEqual(data, { trigger: true, additionalSchema: "additional", anotherSchema: "another" });
-		});
-	});
-
-	describe("type-array", () => {
-		it("should return first type of list for template", () => {
-			const node = compileSchema({
-				type: ["string", "object"]
-			});
-			const res = node.getData();
-
-			assert.deepEqual(res, "");
-		});
-
-		it("should return input data", () => {
-			const node = compileSchema({
-				type: ["string", "object"]
-			});
-			const res = node.getData("title");
-
-			assert.deepEqual(res, "title");
-		});
-
-		it("should return type of default value if data is not given", () => {
-			const node = compileSchema({
-				type: ["string", "array", "object"],
-				default: []
-			});
-			const res = node.getData();
-
-			assert.deepEqual(res, []);
-		});
-	});
-
-	describe("templateOptions", () => {
-		it("should remove invalid oneOf schema if 'removeInvalidData=true'", () => {
-			const node = compileSchema({
-				type: "object",
-				oneOf: [
-					{
-						type: "object",
-						properties: {
-							value: { type: "string", default: "jane" }
-						}
-					},
-					{
-						type: "object",
-						properties: {
-							value: { type: "number" },
-							test: { type: "string", default: "test" }
-						}
-					}
-				]
-			});
-			const res = node.getData(
-				{ value: ["remove-me"] },
-				{
-					removeInvalidData: true
-				}
-			);
-
-			assert.deepEqual(res, {});
-		});
-
-		it("should not add optional properties", () => {
-			const schema = {
-				type: "object",
-				required: ["list", "author"],
-				properties: {
-					title: { type: "string", default: "title" },
-					list: {
-						type: "array",
-						items: {
-							allOf: [
-								{ type: "object" },
-								{
-									properties: {
-										index: { type: "number", default: 4 }
-									}
-								}
-							]
-						}
-					},
-					author: {
-						anyOf: [
-							{ type: "string", default: "jane" },
-							{ type: "string", default: "john" }
-						]
-					},
-					source: {
-						type: "string",
-						enum: ["dpa", "getty"]
-					}
-				}
-			};
-			const node = compileSchema(schema);
-
-			const template = node.getData(
-				{},
-				{
-					addOptionalProps: false
-				}
-			);
-
-			assert.deepEqual({ list: [], author: "jane" }, template);
-		});
-
-		describe("extendDefaults", () => {
-			it("should keep array default-value with 'extendDefaults:false'", () => {
-				const node = compileSchema({
-					type: "array",
-					default: [],
-					items: {
-						type: "string",
-						enum: ["one", "two"]
-					},
-					minItems: 1 // usually adds an enty, but default states: []
-				});
-				const res = node.getData(undefined, {
-					extendDefaults: false
-				});
-
-				assert.deepEqual(res, []);
-			});
-
-			it("should add items to array with no default-value given and 'extendDefaults:false'", () => {
-				const node = compileSchema({
-					type: "array",
-					items: {
-						type: "string",
-						enum: ["one", "two"]
-					},
-					minItems: 1 // usually adds an enty, but default states: []
-				});
-				const res = node.getData(undefined, {
-					extendDefaults: false
-				});
-
-				assert.deepEqual(res, ["one"]);
-			});
-
-			it("should add items to default-array with 'extendDefaults:true'", () => {
-				const node = compileSchema({
-					type: "array",
-					default: [],
-					items: {
-						type: "string",
-						enum: ["one", "two"]
-					},
-					minItems: 1 // usually adds an enty, but default states: []
-				});
-				const res = node.getData(undefined, {
-					extendDefaults: true
-				});
-
-				assert.deepEqual(res, ["one"]);
-			});
-
-			it("should not add required items to object with default-value given and 'extendDefaults:false'", () => {
-				const node = compileSchema({
-					type: "object",
-					required: ["title"],
-					default: {},
-					properties: {
-						title: { type: "string" }
-					}
-				});
-				const res = node.getData(undefined, {
-					extendDefaults: false
-				});
-
-				assert.deepEqual(res, {});
-			});
-
-			it("should extend object by required property with no default-value given and 'extendDefaults:false'", () => {
-				const node = compileSchema({
-					type: "object",
-					required: ["title"],
-					properties: {
-						title: { type: "string" }
-					}
-				});
-				const res = node.getData(undefined, {
-					extendDefaults: false
-				});
-
-				assert.deepEqual(res, { title: "" });
-			});
-			it("should extend default-object with 'extendDefaults:true'", () => {
-				const node = compileSchema({
-					type: "object",
-					required: ["title"],
-					default: {},
-					properties: {
-						title: { type: "string" }
-					}
-				});
-				const res = node.getData(undefined, {
-					extendDefaults: true
-				});
-
-				assert.deepEqual(res, { title: "" });
-			});
-		});
-	});
-
-	describe("defaultTemplateOptions.removeInvalidData", () => {
-		it("should NOT remove invalid data per default", () => {
-			const node = compileSchema({
-				type: "object",
-				properties: { valid: { type: "string" } },
-				additionalProperties: false
-			});
-			const res = node.getData({ valid: "stays", invalid: "not removed" });
-			assert.deepEqual(res, { valid: "stays", invalid: "not removed" });
-		});
-
-		it("should remove invalid data with 'removeInvalidData=true'", () => {
-			const node = compileSchema({
-				type: "object",
-				properties: { valid: { type: "string" } },
-				additionalProperties: false
-			});
-			const res = node.getData({ valid: "stays", invalid: "removes" }, { removeInvalidData: true });
-			assert.deepEqual(res, { valid: "stays" });
-		});
-
-		it("should NOT remove valid but unspecified data when 'removeInvalidData=true'", () => {
-			const node = compileSchema({
-				type: "object",
-				properties: { valid: { type: "string" } }
-			});
-			const res = node.getData({ valid: "stays", unspecified: "stays" }, { removeInvalidData: true });
-			assert.deepEqual(res, { valid: "stays", unspecified: "stays" });
-		});
-
-		it("should remove invalid data with 'removeInvalidData=true' when set as defaultTemplateOptions", () => {
-			const node = compileSchema(
-				{
-					type: "object",
-					properties: { valid: { type: "string" } },
-					additionalProperties: false
-				},
-				{
-					getDataDefaultOptions: { removeInvalidData: true }
-				}
-			);
-			const res = node.getData({ valid: "stays", invalid: "removes" });
-			assert.deepEqual(res, { valid: "stays" });
-		});
-
-		it("should NOT remove invalid data when set per default but overwritten on function", () => {
-			const node = compileSchema(
-				{
-					type: "object",
-					properties: { valid: { type: "string" } },
-					additionalProperties: false
-				},
-				{
-					getDataDefaultOptions: { removeInvalidData: true }
-				}
-			);
-			const res = node.getData({ valid: "stays", invalid: "not removed" }, { removeInvalidData: false });
-			assert.deepEqual(res, { valid: "stays", invalid: "not removed" });
-		});
-	});
-	describe("defaultTemplateOptions.useTypeDefaults", () => {
-		it("should return initial value for missing default-properties", () => {
-			const data = compileSchema({
-				required: ["valid"],
-				properties: { valid: { type: "string" } }
-			}).getData(null, { useTypeDefaults: true });
-
-			assert.deepEqual(data, { valid: "" });
-		});
-
-		it("should omit initial value for missing default-properties", () => {
-			const data = compileSchema({
-				required: ["valid"],
-				properties: { valid: { type: "string" } }
-			}).getData(null, { useTypeDefaults: false });
-
-			assert.deepEqual(data, {});
-		});
-
-		// @todo: reevaluate this behaviour
-		it("should return initial object-value for missing default-properties, even if useTypeDefaults: false", () => {
-			const data = compileSchema({
-				required: ["valid"],
-				properties: { valid: { type: "string" } }
-			}).getData(null, { useTypeDefaults: false });
-
-			assert.deepEqual(data, {});
-		});
-
-		// @todo: reevaluate this behaviour
-		it("should return initial array-value for missing default-properties", () => {
-			const data = compileSchema({
-				required: ["valid"],
-				properties: { valid: { type: "array", items: { type: "string" }, minItems: 1 } }
-			}).getData(null, { useTypeDefaults: false });
-
-			assert.deepEqual(data, { valid: [undefined] });
-		});
-
-		it("should omit properties without default values when 'useTypeDefaults:false' even if required", () => {
-			const node = compileSchema({
-				type: "object",
-				required: ["name", "age", "country"],
-				properties: {
-					name: { type: "string", default: "John Doe" },
-					age: { type: "number" },
-					country: { type: "string", default: "USA" }
-				}
-			});
-			const res = node.getData(undefined, {
-				extendDefaults: false,
-				useTypeDefaults: false
-			});
-
-			assert.deepEqual(res, { name: "John Doe", country: "USA" });
-		});
-
-		it("should omit properties without default values when 'useTypeDefaults:false' even if required in nested", () => {
-			const node = compileSchema({
-				type: "object",
-				properties: {
-					user: {
-						type: "object",
-						required: ["id", "username"],
-						properties: {
-							id: { type: "string" },
-							username: { type: "string", default: "guest" },
-							profile: {
-								type: "object",
-								properties: {
-									bio: { type: "string" },
-									theme: { type: "string", default: "light" }
-								}
-							}
-						}
-					},
-					active: { type: "boolean", default: true }
-				}
-			});
-			const res = node.getData({}, { addOptionalProps: true, useTypeDefaults: false });
-
-			assert.deepEqual(
-				JSON.stringify(res),
-				JSON.stringify({
-					user: {
-						username: "guest",
-						profile: {
-							theme: "light"
-						}
-					},
-					active: true
-				})
-			);
-		});
-
-		it("should handle type string with default value and 'useTypeDefaults:false'", () => {
-			const node = compileSchema({
-				type: "string",
-				default: "default value"
-			});
-			const res = node.getData(undefined, {
-				useTypeDefaults: false
-			});
-			assert.deepEqual(res, "default value");
-		});
-
-		it("should handle type string without default value and 'useTypeDefaults:false'", () => {
-			const node = compileSchema({
-				type: "string"
-			});
-			const res = node.getData(undefined, { useTypeDefaults: false });
-			assert.deepEqual(res, undefined);
-		});
-
-		it("should handle array without default value and 'useTypeDefaults:false'", () => {
-			const node = compileSchema({
-				type: "object",
-				required: ["title"],
-				properties: {
-					title: {
-						type: "array",
-						items: { type: "string" }
-					}
-				}
-			});
-			const res = node.getData(undefined, { useTypeDefaults: false });
-			assert.deepEqual(res, { title: [] });
-		});
-	});
+    it("should not modify input schema", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                title: { type: "string", default: "title" },
+                list: {
+                    type: "array",
+                    items: { allOf: [{ type: "object" }, { properties: { index: { type: "number", default: 4 } } }] }
+                },
+                author: {
+                    anyOf: [
+                        { type: "string", default: "jane" },
+                        { type: "string", default: "john" }
+                    ]
+                },
+                source: { type: "string", enum: ["dpa", "getty"] }
+            }
+        };
+        const originalSchema = JSON.stringify(schema);
+        const node = compileSchema(schema);
+        node.getData({});
+        assert.deepEqual(JSON.stringify(schema), originalSchema);
+    });
+
+    describe("values", () => {
+        it("should return default value missing input and type", () => {
+            const data = compileSchema({ default: 123 }).getData();
+            assert.deepEqual(data, 123);
+        });
+
+        it("should NOT override input value for missing type", () => {
+            const data = compileSchema({ default: 123 }).getData("input");
+            assert.deepEqual(data, "input");
+        });
+
+        // @attention, changing input data
+        it("should alwayys return const value", () => {
+            const data = compileSchema({ const: "const", default: 123 }).getData(123);
+            assert.deepEqual(data, "const");
+        });
+
+        it("should prefer const over default", () => {
+            const data = compileSchema({
+                type: "string",
+                const: "static",
+                default: "should be overwritten"
+            }).getData();
+            assert.deepEqual(data, "static");
+        });
+
+        describe("string", () => {
+            it("should return empty string for missing default value", () => {
+                const data = compileSchema({ type: "string" }).getData();
+                assert.deepEqual(data, "");
+            });
+
+            it("should return default value", () => {
+                const data = compileSchema({
+                    type: "string",
+                    default: "default"
+                }).getData();
+                assert.deepEqual(data, "default");
+            });
+
+            it("should return string data", () => {
+                const data = compileSchema({
+                    type: "string",
+                    default: "default"
+                }).getData("input");
+                assert.deepEqual(data, "input");
+            });
+        });
+
+        describe("number", () => {
+            it("should return 0 for missing default value", () => {
+                const data = compileSchema({ type: "number" }).getData();
+                assert.deepEqual(data, 0);
+            });
+
+            it("should return default value", () => {
+                const data = compileSchema({ type: "number", default: 99 }).getData();
+                assert.deepEqual(data, 99);
+            });
+
+            it("should return number data", () => {
+                const data = compileSchema({ type: "number", default: 99 }).getData(123);
+                assert.deepEqual(data, 123);
+            });
+        });
+
+        describe("integer", () => {});
+
+        describe("boolean", () => {
+            it("should return `false` for missing default value", () => {
+                const data = compileSchema({ type: "boolean", default: false }).getData();
+                assert.deepEqual(data, false);
+            });
+
+            it("should return default value of boolean", () => {
+                const data = compileSchema({ type: "boolean", default: false }).getData();
+                assert.deepEqual(data, false);
+            });
+
+            it("should not override given boolean if it is `false`", () => {
+                const data = compileSchema({ type: "boolean", default: true }).getData(false);
+                assert.deepEqual(data, false);
+            });
+
+            it("should not override given boolean if it is `true`", () => {
+                const data = compileSchema({ type: "boolean", default: false }).getData(true);
+                assert.deepEqual(data, true);
+            });
+        });
+
+        describe("null", () => {
+            it("should return `null` for missing default value", () => {
+                const data = compileSchema({ type: "null" }).getData();
+                assert.deepEqual(data, null);
+            });
+
+            it("should return `null` when first type in type-array", () => {
+                const node = compileSchema({ type: ["null", "string"] });
+                const res = node.getData();
+
+                assert.deepEqual(res, null);
+            });
+
+            it("should return default value of null", () => {
+                const data = compileSchema({ type: "null", default: null }).getData();
+                assert.deepEqual(data, null);
+            });
+
+            it("should return default value of null even for wrong typye", () => {
+                const data = compileSchema({ type: "number", default: null }).getData();
+                assert.deepEqual(data, null);
+            });
+
+            it("should support `null` type properties", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["nullType"],
+                    properties: { nullType: { type: "null" } }
+                }).getData();
+                assert.deepEqual(data, { nullType: null });
+            });
+
+            it("should return `null` input for strings", () => {
+                const data = compileSchema({ type: "string" }).getData(null);
+                assert.deepEqual(data, null);
+            });
+
+            it("should return `null` input for value-property", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["title"],
+                    properties: { title: { type: "number" } }
+                }).getData({ title: null });
+                assert.deepEqual(data, { title: null });
+            });
+        });
+
+        describe("enum", () => {
+            it("should set the first enum option for a missing default", () => {
+                const data = compileSchema({ enum: ["first", "second"] }).getData();
+                assert.deepEqual(data, "first");
+            });
+
+            it("should use default value in any case", () => {
+                const data = compileSchema({ enum: ["first", "second"], default: "" }).getData();
+                assert.deepEqual(data, "");
+            });
+        });
+
+        describe("file", () => {
+            it("should not modify file-instance", () => {
+                const file = new File([], "testfile.pdf");
+                const data = compileSchema({
+                    type: ["string", "object"],
+                    format: "file"
+                }).getData(file);
+                assert.deepEqual(data, file);
+            });
+
+            it("should not modify file-instance on object", () => {
+                const file = new File([], "testfile.pdf");
+                const data = compileSchema({
+                    type: "object",
+                    properties: { file: { type: ["string", "object"], format: "file" } }
+                }).getData({ file });
+                assert.deepEqual(data, { file });
+            });
+        });
+
+        describe("oneOf", () => {
+            it("should return first schema for mixed types", () => {
+                const node = compileSchema({
+                    oneOf: [{ type: "string", default: "jane" }, { type: "number" }]
+                });
+                const res = node.getData();
+
+                assert.deepEqual(res, "jane");
+            });
+        });
+    });
+
+    describe("object", () => {
+        describe("behaviour", () => {
+            it("should return {} for a missing default value", () => {
+                const data = compileSchema({ type: "object" }).getData();
+                assert.deepEqual(data, {});
+            });
+
+            it("should return default value of object", () => {
+                const data = compileSchema({
+                    type: "object",
+                    default: { init: true }
+                }).getData();
+                assert.deepEqual(data, { init: true });
+            });
+
+            it("should return input data", () => {
+                const data = compileSchema({ type: "object" }).getData({ init: false });
+                assert.deepEqual(data, { init: false });
+            });
+
+            it("should override default by input data", () => {
+                const data = compileSchema({
+                    type: "object",
+                    default: { init: true }
+                }).getData({ init: false });
+                assert.deepEqual(data, { init: false });
+            });
+        });
+
+        describe("properties", () => {
+            it("should return default object", () => {
+                const data = compileSchema({
+                    type: "object",
+                    properties: { first: { type: "string" }, second: { type: "number" } },
+                    default: { first: "john", second: 4 }
+                }).getData();
+                assert.deepEqual(data, { first: "john", second: 4 });
+            });
+
+            it("should return only required object properties", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first"],
+                    properties: { first: { type: "string" }, second: { type: "number" } }
+                }).getData();
+                assert.deepEqual(data, { first: "" });
+            });
+
+            it("should not fail on falsy input data", () => {
+                const data = compileSchema({
+                    type: "object",
+                    properties: {
+                        first: { type: "boolean", default: true },
+                        second: { type: "boolean", default: false }
+                    }
+                }).getData({ first: false, second: true });
+                assert.deepEqual(data, { first: false, second: true });
+            });
+
+            it("should return all object properties with `addOptionalProps=true`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" }, second: { type: "number" } }
+                }).getData({}, { addOptionalProps: true });
+                assert.deepEqual(data, { first: "", second: 0 });
+            });
+
+            it("should NOT override given default values by other default values", () => {
+                const data = compileSchema({
+                    type: "object",
+                    properties: { first: { type: "string", default: "jane" }, second: { type: "number" } },
+                    default: { first: "john", second: 4 }
+                }).getData();
+                assert.deepEqual(data, { first: "john", second: 4 });
+            });
+
+            it("should extend given template data by property default values", () => {
+                const data = compileSchema({
+                    type: "object",
+                    properties: { first: { type: "string", default: "jane" }, second: { type: "number" } },
+                    default: { first: "john", second: 4 }
+                }).getData({ second: 8 });
+                assert.deepEqual(data, { first: "john", second: 8 });
+            });
+        });
+
+        describe("additionalProperties & option: removeInvalidData", () => {
+            it("should NOT remove additional properties `additionalProperties=undefined`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" } }
+                }).getData({ first: "first", second: 42 });
+                assert.deepEqual(data, { first: "first", second: 42 });
+            });
+
+            it("should NOT remove additional properties `additionalProperties=true`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" } },
+                    additionalProperties: true
+                }).getData({ first: "first", second: 42 });
+                assert.deepEqual(data, { first: "first", second: 42 });
+            });
+
+            it("should NOT remove non matching properties with `additionalProperties={schema}`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" } },
+                    additionalProperties: { type: "string" }
+                }).getData({ first: "first", second: 42 });
+                assert.deepEqual(data, { first: "first", second: 42 });
+            });
+
+            it("should NOT remove additional properties with `additionalProperties=false`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" } },
+                    additionalProperties: false
+                }).getData({ first: "first", second: 42 });
+                assert.deepEqual(data, { first: "first", second: 42 });
+            });
+
+            it("should remove unmatched properties with option `removeInvalidData=true`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" } },
+                    additionalProperties: false
+                }).getData({ first: "first", second: 42, thrid: "third" }, { removeInvalidData: true });
+                assert.deepEqual(data, { first: "first" });
+            });
+
+            it("should remove invalid properties with option `removeInvalidData=true`", () => {
+                const data = compileSchema({
+                    type: "object",
+                    required: ["first", "second"],
+                    properties: { first: { type: "string" } },
+                    additionalProperties: { type: "number" }
+                }).getData({ first: "first", second: 42, third: "third", fourth: false }, { removeInvalidData: true });
+                assert.deepEqual(data, { first: "first", second: 42 });
+            });
+        });
+
+        // patternNames
+        // patternProperties
+        // dependentSchemas
+        // dependentRequired
+        // (unevaluatedPoperties)
+
+        describe("allOf", () => {
+            it("should create template for merged allOf schema", () => {
+                const data = compileSchema({
+                    type: "object",
+                    allOf: [
+                        {
+                            required: ["name"],
+                            properties: { name: { type: "string", default: "jane" } }
+                        },
+                        {
+                            required: ["stage"],
+                            properties: { stage: { type: "string", default: "test" } }
+                        }
+                    ]
+                }).getData({ name: "john" });
+                assert.deepEqual(data, { name: "john", stage: "test" });
+            });
+        });
+
+        describe("anyOf", () => {
+            it("should create template for first anyOf schema", () => {
+                const node = compileSchema({
+                    type: "object",
+                    anyOf: [
+                        {
+                            required: ["name", "stage"],
+                            properties: {
+                                name: { type: "string", default: "jane" },
+                                stage: { type: "string", default: "develop" }
+                            }
+                        },
+                        {
+                            required: ["stage"],
+                            properties: {
+                                stage: { type: "number", default: 0 }
+                            }
+                        }
+                    ]
+                });
+                const res = node.getData({ name: "john" });
+
+                assert.deepEqual(res, { name: "john", stage: "develop" });
+            });
+        });
+
+        describe("oneOf", () => {
+            it("should return template of first oneOf schema", () => {
+                const node = compileSchema({
+                    type: "object",
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["title"],
+                            properties: {
+                                title: { type: "string", default: "jane" }
+                            }
+                        },
+                        {
+                            type: "object",
+                            required: ["value"],
+                            properties: { value: { type: "number" } }
+                        }
+                    ]
+                });
+                const res = node.getData();
+
+                assert.deepEqual(res, { title: "jane" });
+            });
+
+            it("should extend empty object with first oneOf schema", () => {
+                const node = compileSchema({
+                    type: "object",
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["title"],
+                            properties: {
+                                title: { type: "string", default: "jane" }
+                            }
+                        },
+                        {
+                            type: "object",
+                            required: ["value"],
+                            properties: { value: { type: "number" } }
+                        }
+                    ]
+                });
+                const res = node.getData({});
+
+                assert.deepEqual(res, { title: "jane" });
+            });
+
+            it("should return template of matching oneOf schema", () => {
+                const node = compileSchema({
+                    type: "object",
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["value"],
+                            properties: {
+                                value: { type: "string", default: "jane" }
+                            }
+                        },
+                        {
+                            type: "object",
+                            required: ["value", "test"],
+                            properties: {
+                                value: { type: "number" },
+                                test: { type: "string", default: "test" }
+                            }
+                        }
+                    ]
+                });
+                const res = node.getData({ value: 111 });
+
+                assert.deepEqual(res, { value: 111, test: "test" });
+            });
+
+            it("should return input value if no oneOf-schema matches ", () => {
+                const node = compileSchema({
+                    type: "object",
+                    oneOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                value: { type: "string", default: "jane" }
+                            }
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                value: { type: "number" },
+                                test: { type: "string", default: "test" }
+                            }
+                        }
+                    ]
+                });
+                const res = node.getData({ value: ["keep-me"] });
+
+                assert.deepEqual(res, { value: ["keep-me"] });
+            });
+
+            it("should not require object type definition in oneOf schemas", () => {
+                const node = compileSchema({
+                    type: "object",
+                    oneOf: [
+                        {
+                            required: ["type"],
+                            properties: {
+                                type: { const: "header" }
+                            }
+                        },
+                        {
+                            required: ["type"],
+                            properties: {
+                                type: { const: "paragraph" }
+                            }
+                        }
+                    ]
+                });
+
+                const res = node.getData({ type: "paragraph" });
+                assert.deepEqual(res, { type: "paragraph" });
+            });
+
+            it("should return valid default data", () => {
+                const node = compileSchema({
+                    type: "object",
+                    default: { value: 123 },
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["title"],
+                            properties: { title: { type: "string", default: "jane" } }
+                        },
+                        { type: "object", required: ["value"], properties: { value: { type: "number" } } }
+                    ]
+                });
+                const res = node.getData();
+
+                assert.deepEqual(res, { value: 123 });
+            });
+
+            it("should return invalid default data", () => {
+                const node = compileSchema({
+                    type: "object",
+                    default: { value: "wrong type" },
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["title"],
+                            properties: { title: { type: "string", default: "jane" } }
+                        },
+                        { type: "object", required: ["value"], properties: { value: { type: "number" } } }
+                    ]
+                });
+                const res = node.getData();
+
+                assert.deepEqual(res, { value: "wrong type" });
+            });
+
+            it("should add correct optional properties from schema matching default data", () => {
+                const node = compileSchema({
+                    type: "object",
+                    default: { value: 123 },
+                    oneOf: [
+                        {
+                            type: "object",
+                            required: ["title"],
+                            properties: { title: { type: "string", default: "jane" } }
+                        },
+                        {
+                            type: "object",
+                            required: ["value"],
+                            properties: { value: { type: "number" }, optional: { type: "string" } }
+                        }
+                    ]
+                });
+                const res = node.getData(undefined, { addOptionalProps: true });
+
+                assert.deepEqual(res, { value: 123, optional: "" });
+            });
+        });
+    });
+
+    describe("array", () => {
+        describe("behaviour", () => {
+            it("should return [] for a missing default value", () => {
+                const data = compileSchema({ type: "array" }).getData();
+                assert.deepEqual(data, []);
+            });
+
+            it("should return default value of object", () => {
+                const data = compileSchema({ type: "array", default: [true] }).getData();
+                assert.deepEqual(data, [true]);
+            });
+
+            it("should return input data", () => {
+                const data = compileSchema({ type: "array" }).getData(["input"]);
+                assert.deepEqual(data, ["input"]);
+            });
+
+            it("should override default by input data", () => {
+                const data = compileSchema({
+                    type: "array",
+                    default: ["default"]
+                }).getData(["input"]);
+                assert.deepEqual(data, ["input"]);
+            });
+        });
+
+        describe("items: {}", () => {
+            it("should return empty array if minItems is undefined", () => {
+                const data = compileSchema({ items: { type: "boolean" } }).getData();
+                assert.deepEqual(data, []);
+            });
+
+            it("should return array with length of minItems", () => {
+                const data = compileSchema({
+                    minItems: 3,
+                    items: { type: "boolean" }
+                }).getData();
+                assert(Array.isArray(data));
+                assert.deepEqual(data.length, 3);
+                assert.deepEqual(data, [false, false, false]);
+            });
+
+            it("should return default array even if minItems is not set", () => {
+                const data = compileSchema({
+                    default: ["a", "b"],
+                    items: { type: "string" }
+                }).getData();
+                assert.deepEqual(data, ["a", "b"]);
+            });
+
+            it("should return default array if part of object", () => {
+                const data = compileSchema({
+                    required: ["list"],
+                    properties: { list: { type: "array", default: ["a", "b"], items: { type: "string" } } }
+                }).getData();
+                assert.deepEqual(data, { list: ["a", "b"] });
+            });
+
+            it("should not override given default values", () => {
+                const data = compileSchema({
+                    minItems: 2,
+                    default: ["abba", "doors"],
+                    items: { type: "string", default: "elvis" }
+                }).getData();
+                assert.deepEqual(data, ["abba", "doors"]);
+            });
+
+            it("should extend given template data by default values", () => {
+                const data = compileSchema({
+                    minItems: 2,
+                    default: ["abba", "doors"],
+                    items: { type: "string" }
+                }).getData(["elvis"]);
+                assert.deepEqual(data, ["elvis", "doors"]);
+            });
+
+            it("should extend all input objects by missing properties", () => {
+                const data = compileSchema({
+                    default: ["abba", "doors"],
+                    items: {
+                        type: "object",
+                        required: ["first", "second"],
+                        properties: {
+                            first: { type: "string", default: "first" },
+                            second: { type: "string", default: "second" }
+                        }
+                    }
+                }).getData([{ first: "user input" }, {}]);
+                assert.deepEqual(data, [
+                    { first: "user input", second: "second" },
+                    { first: "first", second: "second" }
+                ]);
+            });
+
+            it("should resolve $ref in items-object", () => {
+                const data = compileSchema({
+                    minItems: 1,
+                    items: { $ref: "/$defs/bool" },
+                    $defs: {
+                        bool: { type: "boolean", default: true }
+                    }
+                }).getData();
+                assert(Array.isArray(data));
+                assert.deepEqual(data.length, 1);
+                assert.deepEqual(data, [true]);
+            });
+        });
+
+        describe("prefixItems: []", () => {
+            // - Tuple validation is useful when the array is a collection of items where each has a different schema
+            // and the ordinal index of each item is meaningful.
+            // - It’s ok to not provide all of the items:
+            // https://spacetelescope.github.io/understanding-json-schema/reference/array.html#tuple-validation
+            it("should return array with minItems in given order", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    prefixItems: [{ type: "string" }, { type: "boolean" }]
+                }).getData();
+                assert.deepEqual(data, ["", false]);
+            });
+
+            it("should not override input items when complementing minItems", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    prefixItems: [{ type: "boolean", default: false }, { type: "string" }]
+                }).getData([true]);
+                assert.deepEqual(data, [true, ""]);
+            });
+
+            it("should not override wrong input items", () => {
+                const data = compileSchema({
+                    type: "array",
+                    prefixItems: [
+                        { type: "boolean", default: false },
+                        { type: "string", default: "default" }
+                    ]
+                }).getData([42, false]);
+                assert.deepEqual(data, [42, "false"]);
+            });
+
+            it("should return default array", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    default: [true],
+                    items: {
+                        type: "boolean"
+                    }
+                }).getData();
+                assert.deepEqual(data, [true]);
+            });
+
+            it("should convert input data for strings", () => {
+                const node = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    prefixItems: [{ type: "string" }]
+                });
+                const res = node.getData([43]);
+
+                assert.deepEqual(res, ["43"]);
+            });
+
+            it("should convert input data for numbers", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    prefixItems: [{ type: "number" }]
+                }).getData(["43"]);
+                assert.deepEqual(data, [43]);
+            });
+
+            it("should convert input data for strings", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    prefixItems: [{ type: "string" }]
+                }).getData([43]);
+                assert.deepEqual(data, ["43"]);
+            });
+
+            it("should NOT convert invalid number if we would lose data", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    prefixItems: [{ type: "number" }]
+                }).getData(["asd"]);
+                assert.deepEqual(data, ["asd"]);
+            });
+
+            it("should convert input data for booleans", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    prefixItems: [{ type: "boolean" }]
+                }).getData(["false"]);
+                assert.deepEqual(data, [false]);
+            });
+
+            it("should NOT convert invalid boolean if we would lose data", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    prefixItems: [{ type: "boolean" }]
+                }).getData(["43"]);
+                assert.deepEqual(data, ["43"]);
+            });
+
+            it("should add defaults from `items`", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    items: {
+                        type: "number",
+                        default: 2
+                    }
+                }).getData([43]);
+                assert.deepEqual(data, [43, 2]);
+            });
+
+            it("should add defaults from `items` for items not in prefixItems", () => {
+                const data = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    prefixItems: [{ type: "boolean" }],
+                    items: { type: "number", default: 2 }
+                }).getData([43]);
+                assert.deepEqual(data, [43, 2]);
+            });
+
+            it("should add prefixItems with `addOptionalProps: true`", () => {
+                const data = compileSchema(
+                    {
+                        type: "array",
+                        prefixItems: [{ type: "boolean", default: true }],
+                        items: { type: "number", default: 2 }
+                    },
+                    {
+                        getDataDefaultOptions: { addOptionalProps: true }
+                    }
+                ).getData();
+                assert.deepEqual(data, [true]);
+            });
+
+            it("should resolve $ref in prefixItems", () => {
+                const node = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    prefixItems: [{ $ref: "/$defs/bool" }, { $ref: "/$defs/string" }],
+                    $defs: {
+                        bool: { type: "boolean" },
+                        string: { type: "string" }
+                    }
+                });
+                const res = node.getData([]);
+
+                assert.deepEqual(res, [false, ""]);
+            });
+        });
+
+        describe("oneOf", () => {
+            it("should return template of first oneOf schema", () => {
+                const node = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    items: {
+                        oneOf: [
+                            { type: "string", default: "target" },
+                            { type: "number", default: 9 }
+                        ]
+                    }
+                });
+                const res = node.getData();
+
+                assert(Array.isArray(res));
+                assert.deepEqual(res.length, 1);
+                assert.deepEqual(res, ["target"]);
+            });
+
+            it("should merge with input data", () => {
+                const node = compileSchema({
+                    type: "array",
+                    minItems: 1,
+                    items: {
+                        oneOf: [
+                            {
+                                type: "object",
+                                required: ["notitle"],
+                                properties: {
+                                    notitle: {
+                                        type: "string",
+                                        default: "nottitle"
+                                    }
+                                }
+                            },
+                            {
+                                type: "object",
+                                required: ["title", "subtitle"],
+                                properties: {
+                                    title: {
+                                        type: "string",
+                                        default: "Standardtitel"
+                                    },
+                                    subtitle: {
+                                        type: "string",
+                                        default: "do not replace with"
+                                    }
+                                }
+                            },
+                            { type: "number", default: 9 }
+                        ]
+                    }
+                });
+
+                const res = node.getData([{ subtitle: "Subtitel" }]);
+
+                assert(Array.isArray(res));
+                assert.deepEqual(res.length, 1);
+                assert.deepEqual(res, [{ title: "Standardtitel", subtitle: "Subtitel" }]);
+            });
+
+            it("should not remove invalid oneOf schema if 'removeInvalidData' is unset", () => {
+                const node = compileSchema({
+                    type: "object",
+                    properties: {
+                        filter: {
+                            $ref: "#/definitions/filter"
+                        }
+                    },
+                    definitions: {
+                        filter: {
+                            type: "array",
+                            items: {
+                                oneOf: [
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            op: {
+                                                const: "in"
+                                            },
+                                            property: { type: "string", minLength: 1 }
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                });
+                const res = node.getData({ filter: [{ op: "möp" }] });
+                assert.deepEqual(res, { filter: [{ op: "möp" }] });
+            });
+        });
+
+        describe("allOf", () => {
+            it("should create template for merged allOf schema", () => {
+                const node = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    items: {
+                        type: "object",
+                        allOf: [
+                            {
+                                required: ["title"],
+                                properties: {
+                                    title: { type: "string", default: "title" }
+                                }
+                            },
+                            {
+                                required: ["caption"],
+                                properties: {
+                                    caption: {
+                                        type: "string",
+                                        default: "caption"
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                });
+
+                const res = node.getData([{ title: "given-title" }]);
+                assert.deepEqual(res, [
+                    { title: "given-title", caption: "caption" },
+                    { title: "title", caption: "caption" }
+                ]);
+            });
+        });
+
+        describe("anyOf", () => {
+            it("should create template for first anyOf schema", () => {
+                const node = compileSchema({
+                    type: "array",
+                    minItems: 2,
+                    items: {
+                        type: "object",
+                        anyOf: [
+                            {
+                                required: ["title"],
+                                properties: {
+                                    title: { type: "string", default: "title" }
+                                }
+                            },
+                            {
+                                required: ["properties"],
+                                properties: {
+                                    caption: {
+                                        type: "string",
+                                        default: "caption"
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                });
+
+                const res = node.getData([{ title: "given-title" }]);
+                assert.deepEqual(res, [{ title: "given-title" }, { title: "title" }]);
+            });
+        });
+
+        // draft07 (backwards compatible)
+        describe("dependencies", () => {
+            describe("option: `additionalProps: false`", () => {
+                const TEMPLATE_OPTIONS = { addOptionalProps: false };
+                describe("dependency required", () => {
+                    it("should not add dependency if it is not required", () => {
+                        const node = compileSchema({
+                            type: "object",
+                            properties: {
+                                trigger: { type: "string" },
+                                dependency: { type: "string", default: "default" }
+                            },
+                            dependencies: {
+                                trigger: ["dependency"]
+                            }
+                        });
+
+                        const res = node.getData({}, TEMPLATE_OPTIONS);
+                        assert.deepEqual(res, {});
+                    });
+
+                    it("should add dependency if triggered as required", () => {
+                        const node = compileSchema({
+                            type: "object",
+                            properties: {
+                                trigger: { type: "string" },
+                                dependency: { type: "string", default: "default" }
+                            },
+                            dependencies: {
+                                trigger: ["dependency"]
+                            }
+                        });
+
+                        const res = node.getData({ trigger: "yes" }, TEMPLATE_OPTIONS);
+                        assert.deepEqual(res, { trigger: "yes", dependency: "default" });
+                    });
+
+                    it("should add dependency if initially triggered as required", () => {
+                        const node = compileSchema({
+                            type: "object",
+                            required: ["trigger"],
+                            properties: {
+                                trigger: { type: "string" },
+                                dependency: { type: "string", default: "default" }
+                            },
+                            dependencies: {
+                                trigger: ["dependency"]
+                            }
+                        });
+
+                        const res = node.getData({}, TEMPLATE_OPTIONS);
+                        assert.deepEqual(res, { trigger: "", dependency: "default" });
+                    });
+                });
+
+                describe("dependency schema", () => {
+                    it("should not add dependency from schema if it is not required", () => {
+                        const node = compileSchema({
+                            type: "object",
+                            properties: {
+                                trigger: { type: "string" }
+                            },
+                            dependencies: {
+                                trigger: {
+                                    properties: {
+                                        dependency: { type: "string", default: "default" }
+                                    }
+                                }
+                            }
+                        });
+
+                        const res = node.getData({}, TEMPLATE_OPTIONS);
+                        assert.deepEqual(res, {});
+                    });
+
+                    it("should add dependency from schema if triggered as required", () => {
+                        const node = compileSchema({
+                            type: "object",
+                            properties: {
+                                trigger: { type: "string" }
+                            },
+                            dependencies: {
+                                trigger: {
+                                    required: ["dependency"],
+                                    properties: {
+                                        dependency: { type: "string", default: "default" }
+                                    }
+                                }
+                            }
+                        });
+
+                        const res = node.getData({ trigger: "yes" }, TEMPLATE_OPTIONS);
+                        assert.deepEqual(res, { trigger: "yes", dependency: "default" });
+                    });
+                });
+            });
+
+            describe("option: `additionalProps: true`", () => {
+                it("should create template for valid dependency", () => {
+                    const node = compileSchema({
+                        type: "object",
+                        properties: {
+                            test: { type: "string", default: "tested value" }
+                        },
+                        dependencies: {
+                            test: {
+                                properties: {
+                                    additionalValue: { type: "string", default: "additional" }
+                                }
+                            }
+                        }
+                    });
+                    const res = node.getData(undefined, {
+                        addOptionalProps: true
+                    });
+                    assert.deepEqual(res, {
+                        test: "tested value",
+                        additionalValue: "additional"
+                    });
+                });
+
+                it("should not change passed value of dependency", () => {
+                    const node = compileSchema({
+                        type: "object",
+                        properties: {
+                            test: { type: "string", default: "tested value" }
+                        },
+                        dependencies: {
+                            test: {
+                                properties: {
+                                    additionalValue: { type: "string", default: "additional" }
+                                }
+                            }
+                        }
+                    });
+                    const res = node.getData(
+                        { additionalValue: "input value" },
+                        {
+                            addOptionalProps: true
+                        }
+                    );
+                    assert.deepEqual(res, {
+                        test: "tested value",
+                        additionalValue: "input value"
+                    });
+                });
+
+                it("should not create data for non matching dependency", () => {
+                    const node = compileSchema({
+                        type: "object",
+                        properties: {
+                            test: { type: "string", default: "tested value" }
+                        },
+                        dependencies: {
+                            unknown: {
+                                properties: {
+                                    additionalValue: { type: "string", default: "additional" }
+                                }
+                            }
+                        }
+                    });
+                    const res = node.getData(undefined, {
+                        addOptionalProps: true
+                    });
+                    assert.deepEqual(res, { test: "tested value" });
+                });
+            });
+        });
+    });
+
+    describe("$ref", () => {
+        it("should return default value of resolved ref", () => {
+            const data = compileSchema({
+                $ref: "#/$defs/once",
+                $defs: { once: { default: "once" } }
+            }).getData();
+            assert.deepEqual(data, "once");
+        });
+
+        it("should follow all refs", () => {
+            const data = compileSchema({
+                $ref: "#/$defs/once",
+                $defs: { once: { $ref: "#/$defs/twice" }, twice: { default: "twice" } }
+            }).getData();
+            assert.deepEqual(data, "twice");
+        });
+
+        it("should resolve $ref in object schema", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["first"],
+                properties: { first: { $ref: "#/definitions/first" } },
+                definitions: { first: { type: "string", default: "john" } }
+            }).getData();
+            assert.deepEqual(data, { first: "john" });
+        });
+
+        it("should create template for all followed refs (draft 2019-09)", () => {
+            const data = compileSchema({
+                $ref: "#/$defs/once",
+                $defs: {
+                    once: { required: ["once"], properties: { once: { type: "number" } }, $ref: "#/$defs/twice" },
+                    twice: { required: ["twice"], properties: { twice: { type: "boolean", default: true } } }
+                }
+            }).getData();
+            assert.deepEqual(data, { once: 0, twice: true });
+        });
+
+        it("should resolve $ref in items-array", () => {
+            const data = compileSchema({
+                type: "array",
+                prefixItems: [{ $ref: "#/definitions/first" }],
+                definitions: {
+                    first: {
+                        type: "object",
+                        required: ["first"],
+                        properties: { first: { type: "string", default: "john" } }
+                    }
+                }
+            }).getData([{}, {}]);
+            assert.deepEqual(data, [{ first: "john" }, {}]);
+        });
+
+        it("should follow $ref once", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["value", "nodes"],
+                properties: {
+                    value: { type: "string", default: "node" },
+                    nodes: { type: "array", minItems: 1, items: { $ref: "#" } }
+                }
+            }).getData({}, { recursionLimit: 1 });
+            assert.deepEqual(data, { value: "node", nodes: [{ value: "node", nodes: [] }] });
+        });
+
+        it("should resolve all reoccuring refs ", () => {
+            const data = compileSchema({
+                minItems: 3,
+                items: {
+                    $ref: "#/$defs/item"
+                },
+                $defs: {
+                    item: {
+                        required: ["type"],
+                        properties: {
+                            type: {
+                                const: "node"
+                                // $ref: "#"
+                            }
+                        }
+                    }
+                }
+            }).getData([], { recursionLimit: 1 });
+            assert.deepEqual(data, [{ type: "node" }, { type: "node" }, { type: "node" }]);
+        });
+
+        // iteration depth is 1, input-depth is 2 => still add template to depth 2
+        it("should respect depth of input data in $ref-resolution", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["value", "nodes"],
+                properties: {
+                    value: { type: "string", default: "node" },
+                    nodes: { type: "array", minItems: 1, items: { $ref: "#" } }
+                }
+            }).getData(
+                { nodes: [{ value: "input-node" }, { nodes: [{ nodes: [] }] }] },
+                {
+                    recursionLimit: 1
+                }
+            );
+
+            assert.deepEqual(data, {
+                value: "node",
+                nodes: [
+                    {
+                        value: "input-node",
+                        nodes: []
+                    },
+                    {
+                        value: "node",
+                        nodes: [
+                            {
+                                value: "node",
+                                nodes: []
+                            }
+                        ]
+                    }
+                ]
+            });
+        });
+
+        it("should create template of draft04", () => {
+            const schema = require("../../remotes/draft04.json");
+            const node = compileSchema({ ...schema, $schema: "draft-06" });
+            const res = node.getData({}, { addOptionalProps: true });
+            // console.log("RESULT\n", JSON.stringify(res, null, 2));
+            assert.deepEqual(Object.prototype.toString.call(res), "[object Object]");
+        });
+
+        it("should create template of draft07", () => {
+            const data = compileSchema(require("../../remotes/draft07.json")).getData({}, { addOptionalProps: true });
+            // console.log("RESULT\n", JSON.stringify(data, null, 2));
+            assert.deepEqual(Object.prototype.toString.call(data), "[object Object]");
+        });
+    });
+
+    describe("if-then-else", () => {
+        it("should return template of then-schema for valid if-schema", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["test"],
+                properties: { test: { type: "string", default: "with value" } },
+                if: { properties: { test: { type: "string", minLength: 4 } } },
+                then: { required: ["dynamic"], properties: { dynamic: { type: "string", default: "from then" } } }
+            }).getData();
+            assert.deepEqual(data, {
+                test: "with value",
+                dynamic: "from then"
+            });
+        });
+
+        it("should NOT create data for then-schema if it is not required", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["test"],
+                properties: { test: { type: "string", default: "with value" } },
+                if: { properties: { test: { type: "string", minLength: 4 } } },
+                then: { properties: { dynamic: { type: "string", default: "from then" } } }
+            }).getData(undefined, { addOptionalProps: false });
+            assert.deepEqual(data, { test: "with value" });
+        });
+
+        it("should NOT return template of then-schema for invalid if-schema", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["test"],
+                properties: { test: { type: "string", default: "too short" } },
+                if: { properties: { test: { type: "string", minLength: 40 } } },
+                then: { properties: { dynamic: { type: "string", default: "from then" } } }
+            }).getData();
+            assert.deepEqual(data, { test: "too short" });
+        });
+
+        it("should return template of else-schema for invalid if-schema", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["test"],
+                properties: { test: { type: "string", default: "with test" } },
+                if: { properties: { test: { type: "string", minLength: 40 } } },
+                then: { required: ["dynamic"], properties: { dynamic: { type: "string", default: "from then" } } },
+                else: { required: ["dynamic"], properties: { dynamic: { type: "string", default: "from else" } } }
+            }).getData();
+            assert.deepEqual(data, { test: "with test", dynamic: "from else" });
+        });
+
+        it("should incrementally resolve multiple 'then'-schema", () => {
+            const data = compileSchema({
+                type: "object",
+                required: ["trigger"],
+                properties: { trigger: { type: "boolean" } },
+                allOf: [
+                    {
+                        if: { properties: { trigger: { const: true } } },
+                        then: {
+                            required: ["additionalSchema"],
+                            properties: { additionalSchema: { type: "string", default: "additional" } }
+                        }
+                    },
+                    {
+                        if: { required: ["additionalSchema"], properties: { additionalSchema: { minLength: 5 } } },
+                        then: {
+                            required: ["anotherSchema"],
+                            properties: { anotherSchema: { type: "string", default: "another" } }
+                        }
+                    }
+                ]
+            }).getData({ trigger: true });
+            assert.deepEqual(data, { trigger: true, additionalSchema: "additional", anotherSchema: "another" });
+        });
+    });
+
+    describe("type-array", () => {
+        it("should return first type of list for template", () => {
+            const node = compileSchema({
+                type: ["string", "object"]
+            });
+            const res = node.getData();
+
+            assert.deepEqual(res, "");
+        });
+
+        it("should return input data", () => {
+            const node = compileSchema({
+                type: ["string", "object"]
+            });
+            const res = node.getData("title");
+
+            assert.deepEqual(res, "title");
+        });
+
+        it("should return type of default value if data is not given", () => {
+            const node = compileSchema({
+                type: ["string", "array", "object"],
+                default: []
+            });
+            const res = node.getData();
+
+            assert.deepEqual(res, []);
+        });
+    });
+
+    describe("templateOptions", () => {
+        it("should remove invalid oneOf schema if 'removeInvalidData=true'", () => {
+            const node = compileSchema({
+                type: "object",
+                oneOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            value: { type: "string", default: "jane" }
+                        }
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            value: { type: "number" },
+                            test: { type: "string", default: "test" }
+                        }
+                    }
+                ]
+            });
+            const res = node.getData(
+                { value: ["remove-me"] },
+                {
+                    removeInvalidData: true
+                }
+            );
+
+            assert.deepEqual(res, {});
+        });
+
+        it("should not add optional properties", () => {
+            const schema = {
+                type: "object",
+                required: ["list", "author"],
+                properties: {
+                    title: { type: "string", default: "title" },
+                    list: {
+                        type: "array",
+                        items: {
+                            allOf: [
+                                { type: "object" },
+                                {
+                                    properties: {
+                                        index: { type: "number", default: 4 }
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    author: {
+                        anyOf: [
+                            { type: "string", default: "jane" },
+                            { type: "string", default: "john" }
+                        ]
+                    },
+                    source: {
+                        type: "string",
+                        enum: ["dpa", "getty"]
+                    }
+                }
+            };
+            const node = compileSchema(schema);
+
+            const template = node.getData(
+                {},
+                {
+                    addOptionalProps: false
+                }
+            );
+
+            assert.deepEqual({ list: [], author: "jane" }, template);
+        });
+
+        describe("extendDefaults", () => {
+            it("should keep array default-value with 'extendDefaults:false'", () => {
+                const node = compileSchema({
+                    type: "array",
+                    default: [],
+                    items: {
+                        type: "string",
+                        enum: ["one", "two"]
+                    },
+                    minItems: 1 // usually adds an enty, but default states: []
+                });
+                const res = node.getData(undefined, {
+                    extendDefaults: false
+                });
+
+                assert.deepEqual(res, []);
+            });
+
+            it("should add items to array with no default-value given and 'extendDefaults:false'", () => {
+                const node = compileSchema({
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: ["one", "two"]
+                    },
+                    minItems: 1 // usually adds an enty, but default states: []
+                });
+                const res = node.getData(undefined, {
+                    extendDefaults: false
+                });
+
+                assert.deepEqual(res, ["one"]);
+            });
+
+            it("should add items to default-array with 'extendDefaults:true'", () => {
+                const node = compileSchema({
+                    type: "array",
+                    default: [],
+                    items: {
+                        type: "string",
+                        enum: ["one", "two"]
+                    },
+                    minItems: 1 // usually adds an enty, but default states: []
+                });
+                const res = node.getData(undefined, {
+                    extendDefaults: true
+                });
+
+                assert.deepEqual(res, ["one"]);
+            });
+
+            it("should not add required items to object with default-value given and 'extendDefaults:false'", () => {
+                const node = compileSchema({
+                    type: "object",
+                    required: ["title"],
+                    default: {},
+                    properties: {
+                        title: { type: "string" }
+                    }
+                });
+                const res = node.getData(undefined, {
+                    extendDefaults: false
+                });
+
+                assert.deepEqual(res, {});
+            });
+
+            it("should extend object by required property with no default-value given and 'extendDefaults:false'", () => {
+                const node = compileSchema({
+                    type: "object",
+                    required: ["title"],
+                    properties: {
+                        title: { type: "string" }
+                    }
+                });
+                const res = node.getData(undefined, {
+                    extendDefaults: false
+                });
+
+                assert.deepEqual(res, { title: "" });
+            });
+            it("should extend default-object with 'extendDefaults:true'", () => {
+                const node = compileSchema({
+                    type: "object",
+                    required: ["title"],
+                    default: {},
+                    properties: {
+                        title: { type: "string" }
+                    }
+                });
+                const res = node.getData(undefined, {
+                    extendDefaults: true
+                });
+
+                assert.deepEqual(res, { title: "" });
+            });
+        });
+    });
+
+    describe("defaultTemplateOptions.removeInvalidData", () => {
+        it("should NOT remove invalid data per default", () => {
+            const node = compileSchema({
+                type: "object",
+                properties: { valid: { type: "string" } },
+                additionalProperties: false
+            });
+            const res = node.getData({ valid: "stays", invalid: "not removed" });
+            assert.deepEqual(res, { valid: "stays", invalid: "not removed" });
+        });
+
+        it("should remove invalid data with 'removeInvalidData=true'", () => {
+            const node = compileSchema({
+                type: "object",
+                properties: { valid: { type: "string" } },
+                additionalProperties: false
+            });
+            const res = node.getData({ valid: "stays", invalid: "removes" }, { removeInvalidData: true });
+            assert.deepEqual(res, { valid: "stays" });
+        });
+
+        it("should NOT remove valid but unspecified data when 'removeInvalidData=true'", () => {
+            const node = compileSchema({
+                type: "object",
+                properties: { valid: { type: "string" } }
+            });
+            const res = node.getData({ valid: "stays", unspecified: "stays" }, { removeInvalidData: true });
+            assert.deepEqual(res, { valid: "stays", unspecified: "stays" });
+        });
+
+        it("should remove invalid data with 'removeInvalidData=true' when set as defaultTemplateOptions", () => {
+            const node = compileSchema(
+                {
+                    type: "object",
+                    properties: { valid: { type: "string" } },
+                    additionalProperties: false
+                },
+                {
+                    getDataDefaultOptions: { removeInvalidData: true }
+                }
+            );
+            const res = node.getData({ valid: "stays", invalid: "removes" });
+            assert.deepEqual(res, { valid: "stays" });
+        });
+
+        it("should NOT remove invalid data when set per default but overwritten on function", () => {
+            const node = compileSchema(
+                {
+                    type: "object",
+                    properties: { valid: { type: "string" } },
+                    additionalProperties: false
+                },
+                {
+                    getDataDefaultOptions: { removeInvalidData: true }
+                }
+            );
+            const res = node.getData({ valid: "stays", invalid: "not removed" }, { removeInvalidData: false });
+            assert.deepEqual(res, { valid: "stays", invalid: "not removed" });
+        });
+    });
+    describe("defaultTemplateOptions.useTypeDefaults", () => {
+        it("should return initial value for missing default-properties", () => {
+            const data = compileSchema({
+                required: ["valid"],
+                properties: { valid: { type: "string" } }
+            }).getData(null, { useTypeDefaults: true });
+
+            assert.deepEqual(data, { valid: "" });
+        });
+
+        it("should omit initial value for missing default-properties", () => {
+            const data = compileSchema({
+                required: ["valid"],
+                properties: { valid: { type: "string" } }
+            }).getData(null, { useTypeDefaults: false });
+
+            assert.deepEqual(data, {});
+        });
+
+        // @todo: reevaluate this behaviour
+        it("should return initial object-value for missing default-properties, even if useTypeDefaults: false", () => {
+            const data = compileSchema({
+                required: ["valid"],
+                properties: { valid: { type: "string" } }
+            }).getData(null, { useTypeDefaults: false });
+
+            assert.deepEqual(data, {});
+        });
+
+        // @todo: reevaluate this behaviour
+        it("should return initial array-value for missing default-properties", () => {
+            const data = compileSchema({
+                required: ["valid"],
+                properties: { valid: { type: "array", items: { type: "string" }, minItems: 1 } }
+            }).getData(null, { useTypeDefaults: false });
+
+            assert.deepEqual(data, { valid: [undefined] });
+        });
+
+        it("should omit properties without default values when 'useTypeDefaults:false' even if required", () => {
+            const node = compileSchema({
+                type: "object",
+                required: ["name", "age", "country"],
+                properties: {
+                    name: { type: "string", default: "John Doe" },
+                    age: { type: "number" },
+                    country: { type: "string", default: "USA" }
+                }
+            });
+            const res = node.getData(undefined, {
+                extendDefaults: false,
+                useTypeDefaults: false
+            });
+
+            assert.deepEqual(res, { name: "John Doe", country: "USA" });
+        });
+
+        it("should omit properties without default values when 'useTypeDefaults:false' even if required in nested", () => {
+            const node = compileSchema({
+                type: "object",
+                properties: {
+                    user: {
+                        type: "object",
+                        required: ["id", "username"],
+                        properties: {
+                            id: { type: "string" },
+                            username: { type: "string", default: "guest" },
+                            profile: {
+                                type: "object",
+                                properties: {
+                                    bio: { type: "string" },
+                                    theme: { type: "string", default: "light" }
+                                }
+                            }
+                        }
+                    },
+                    active: { type: "boolean", default: true }
+                }
+            });
+            const res = node.getData({}, { addOptionalProps: true, useTypeDefaults: false });
+
+            assert.deepEqual(
+                JSON.stringify(res),
+                JSON.stringify({
+                    user: {
+                        username: "guest",
+                        profile: {
+                            theme: "light"
+                        }
+                    },
+                    active: true
+                })
+            );
+        });
+
+        it("should handle type string with default value and 'useTypeDefaults:false'", () => {
+            const node = compileSchema({
+                type: "string",
+                default: "default value"
+            });
+            const res = node.getData(undefined, {
+                useTypeDefaults: false
+            });
+            assert.deepEqual(res, "default value");
+        });
+
+        it("should handle type string without default value and 'useTypeDefaults:false'", () => {
+            const node = compileSchema({
+                type: "string"
+            });
+            const res = node.getData(undefined, { useTypeDefaults: false });
+            assert.deepEqual(res, undefined);
+        });
+
+        it("should handle array without default value and 'useTypeDefaults:false'", () => {
+            const node = compileSchema({
+                type: "object",
+                required: ["title"],
+                properties: {
+                    title: {
+                        type: "array",
+                        items: { type: "string" }
+                    }
+                }
+            });
+            const res = node.getData(undefined, { useTypeDefaults: false });
+            assert.deepEqual(res, { title: [] });
+        });
+    });
 });