@maroonedog/luq 2.4.4 → 2.5.0

package/README.md

@@ -50,10 +50,16 @@ an array wildcard gets a red squiggle, not a validator that passes everything.
 
 Two consequences worth knowing before you read further:
 
-- **Adoption is a patch, not a migration.** A path you did not declare is not
+- **Adoption is a patch, and so is removal.** A path you did not declare is not
   validated, not required, and not read, so a partly-covered type is a normal
   state rather than a half-finished one. There is nothing global to migrate: no
-  registry, no plugin installation, no shared configuration object.
+  registry, no plugin installation, no shared configuration object. Leaving is
+  the same size of change in the other direction — your types were never
+  authored here, so there is no generated file to delete and no inferred type to
+  replace by hand, and a consumer that takes a [Standard
+  Schema](https://luq.dev/standard-schema) does not change when you hand it a
+  different value. The rules themselves you would rewrite; that part is real,
+  and it is the same work whichever way you go.
 - **Every rule you can call is a plugin you imported by name**, so the bundle
   contains what you used and nothing else — an unimported plugin's method does
   not even typecheck. What each configuration costs is measured on every build:
@@ -95,7 +101,9 @@ somewhere.
 npm install @maroonedog/luq
 ```
 
-Zero runtime dependencies. TypeScript 5.0 or later.
+Zero runtime dependencies. TypeScript 5.0 or later. Your `tsconfig.json` does
+not need `strict` for any of the compile errors above, and they are checked with
+it on as well.
 
 ## The whole API
 
@@ -139,6 +147,36 @@ if (!result.valid) {
 not validated, not required and not read, so covering a type partly is a normal
 state rather than a half-finished one.
 
+### `.strict()` — when you want the whole type covered
+
+Partial cover is the default, so nothing tells you a field was forgotten. Add
+`.strict()` before `.build()` and the compiler does: it asserts every leaf path
+of your type has been declared, and if one is missing the returned object has
+no `build()` and names what is missing.
+
+```ts
+import { Builder } from "@maroonedog/luq";
+import { requiredPlugin } from "@maroonedog/luq/plugins/required";
+
+interface Pair {
+  readonly left: string;
+  readonly right: string;
+}
+
+export const pairs = Builder()
+  .use(requiredPlugin)
+  .for<Pair>()
+  .v("left", (b) => b.string.required())
+  .v("right", (b) => b.string.required())
+  .strict() //  drop either .v() above and this line stops compiling
+  .build();
+```
+
+It has no runtime effect and rejects no extra property at run time — it is a
+statement about your declarations, not about the data. For refusing unknown
+keys in the value, see
+[objectAdditionalProperties](https://luq.dev/plugins).
+
 ### What a built validator gives you
 
 ```ts

package/dist/json-schema/array-keyword-guards.d.ts

@@ -0,0 +1,31 @@
+import type { Draft07Schema, Draft07SchemaObject } from "./draft07.types";
+/** The two shapes §9.3.1 permits `items` to take. */
+export type ItemsValue = Draft07Schema | readonly Draft07Schema[];
+/**
+ * Reads `items` after checking it against the meta-schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal when it is
+ * neither of the two forms §9.3.1 defines.
+ */
+export declare function readCheckedItems(schema: Draft07SchemaObject): ItemsValue | undefined;
+/**
+ * Reads `additionalItems` after checking it is a single schema: the keyword's
+ * own value, or undefined when the keyword is absent, and a refusal for
+ * anything §4.4 does not call a schema.
+ *
+ * It is read only where §6.4.2 gives the keyword effect, which is beside the
+ * tuple form of `items`; beside the single form the draft ignores it, no rest
+ * branch is built and this reader is never reached.
+ */
+export declare function readCheckedAdditionalItems(schema: Draft07SchemaObject): Draft07Schema | undefined;
+/**
+ * Reads `contains` after checking it is a single schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal for anything
+ * §4.4 does not call a schema. Unlike `items`, `contains` has no array form —
+ * a tuple there is a malformed value, not a second reading.
+ */
+export declare function readCheckedContains(schema: Draft07SchemaObject): Draft07Schema | undefined;
+/**
+ * Reads `uniqueItems` after checking it is a boolean: the keyword's own value,
+ * or undefined when the keyword is absent, and a refusal for anything else.
+ */
+export declare function readCheckedUniqueItems(schema: Draft07SchemaObject): boolean | undefined;

package/dist/json-schema/array-keyword-guards.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCheckedItems = readCheckedItems;
+exports.readCheckedAdditionalItems = readCheckedAdditionalItems;
+exports.readCheckedContains = readCheckedContains;
+exports.readCheckedUniqueItems = readCheckedUniqueItems;
+// ===========================================================================
+// L8  src/json-schema/array-keyword-guards.ts — the meta-schema checks for
+// `items`, `additionalItems`, `contains` and `uniqueItems`, read by
+// flatten-array-schema.ts.
+//
+// Every one of these keywords decides whether a rule EXISTS, and each had a
+// route where a value the meta-schema forbids produced no rule at all rather
+// than an error. `items: 5` is not a schema, but the sub-schema walker takes it
+// anyway and iterates its keys; a number has none, so the walker yields zero
+// rules and every element passes — the document asked for a constraint and the
+// built validator carries an always-true one in its place. `additionalItems: 5`
+// takes that same route for the rest branch, so every element past the tuple
+// goes unchecked. `contains: 5` is the same bug wearing a disguise: an
+// always-true element branch matches the FIRST element, so the existence
+// requirement collapses into "the array is non-empty" — the empty array is
+// still refused, and that lawful-looking verdict is what makes the loss of the
+// real constraint easy to miss. `uniqueItems` is honoured only on a strict
+// `=== true`, so `uniqueItems: "yes"`, the shape a form encoding or a loose
+// YAML loader produces, drops to nothing the same way.
+//
+// A validator that quietly enforces LESS than its document says cannot be
+// detected downstream: it answers "valid" for exactly the inputs the schema
+// meant to refuse, and nothing in the result says a constraint went missing.
+// Build time is therefore the only place a caller can still act, so these
+// read the value and refuse it there.
+//
+// What must survive the refusal, because Draft-07 defines it: `items` has TWO
+// legal forms — one schema for every element, or an ARRAY of schemas where
+// position i constrains element i (§9.3.1) — `additionalItems` and `contains`
+// take the boolean form of a schema as readily as the object form (§4.4), and
+// `uniqueItems: false` is a lawful no-op (§6.4.3), so only a NON-boolean is
+// refused.
+// ===========================================================================
+const types_1 = require("../types");
+const draft07_types_1 = require("./draft07.types");
+const malformed_schema_error_1 = require("./malformed-schema-error");
+const ITEMS_REASON = "the value must be a schema or an array of schemas";
+const UNIQUE_ITEMS_REASON = "the value must be a boolean";
+/**
+ * Reads `items` after checking it against the meta-schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal when it is
+ * neither of the two forms §9.3.1 defines.
+ */
+function readCheckedItems(schema) {
+    const items = schema.items;
+    if (items === undefined)
+        return undefined;
+    if ((0, types_1.isArray)(items))
+        return checkTuplePositions(items);
+    if (!(0, draft07_types_1.isDraft07Schema)(items)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("items", ITEMS_REASON, items);
+    }
+    return items;
+}
+/**
+ * Every position of the tuple form is a schema in its own right, so a bad one
+ * names its index: with the whole array rendered instead, a caller holding a
+ * long tuple is told only that something in it is wrong.
+ */
+function checkTuplePositions(positions) {
+    for (let index = 0; index < positions.length; index += 1) {
+        const position = positions[index];
+        if ((0, draft07_types_1.isDraft07Schema)(position))
+            continue;
+        throw new malformed_schema_error_1.MalformedSchemaError("items", `position ${String(index)} of the array form ${malformed_schema_error_1.SCHEMA_FORMS}`, position);
+    }
+    return positions;
+}
+/**
+ * Reads `additionalItems` after checking it is a single schema: the keyword's
+ * own value, or undefined when the keyword is absent, and a refusal for
+ * anything §4.4 does not call a schema.
+ *
+ * It is read only where §6.4.2 gives the keyword effect, which is beside the
+ * tuple form of `items`; beside the single form the draft ignores it, no rest
+ * branch is built and this reader is never reached.
+ */
+function readCheckedAdditionalItems(schema) {
+    const additionalItems = schema.additionalItems;
+    if (additionalItems === undefined)
+        return undefined;
+    if (!(0, draft07_types_1.isDraft07Schema)(additionalItems)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("additionalItems", `the value ${malformed_schema_error_1.SCHEMA_FORMS}`, additionalItems);
+    }
+    return additionalItems;
+}
+/**
+ * Reads `contains` after checking it is a single schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal for anything
+ * §4.4 does not call a schema. Unlike `items`, `contains` has no array form —
+ * a tuple there is a malformed value, not a second reading.
+ */
+function readCheckedContains(schema) {
+    const contains = schema.contains;
+    if (contains === undefined)
+        return undefined;
+    if (!(0, draft07_types_1.isDraft07Schema)(contains)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("contains", `the value ${malformed_schema_error_1.SCHEMA_FORMS}`, contains);
+    }
+    return contains;
+}
+/**
+ * Reads `uniqueItems` after checking it is a boolean: the keyword's own value,
+ * or undefined when the keyword is absent, and a refusal for anything else.
+ */
+function readCheckedUniqueItems(schema) {
+    const uniqueItems = schema.uniqueItems;
+    if (uniqueItems === undefined)
+        return undefined;
+    if (typeof uniqueItems !== "boolean") {
+        throw new malformed_schema_error_1.MalformedSchemaError("uniqueItems", UNIQUE_ITEMS_REASON, uniqueItems);
+    }
+    return uniqueItems;
+}

package/dist/json-schema/array-keyword-guards.mjs

@@ -0,0 +1,114 @@
+// ===========================================================================
+// L8  src/json-schema/array-keyword-guards.ts — the meta-schema checks for
+// `items`, `additionalItems`, `contains` and `uniqueItems`, read by
+// flatten-array-schema.ts.
+//
+// Every one of these keywords decides whether a rule EXISTS, and each had a
+// route where a value the meta-schema forbids produced no rule at all rather
+// than an error. `items: 5` is not a schema, but the sub-schema walker takes it
+// anyway and iterates its keys; a number has none, so the walker yields zero
+// rules and every element passes — the document asked for a constraint and the
+// built validator carries an always-true one in its place. `additionalItems: 5`
+// takes that same route for the rest branch, so every element past the tuple
+// goes unchecked. `contains: 5` is the same bug wearing a disguise: an
+// always-true element branch matches the FIRST element, so the existence
+// requirement collapses into "the array is non-empty" — the empty array is
+// still refused, and that lawful-looking verdict is what makes the loss of the
+// real constraint easy to miss. `uniqueItems` is honoured only on a strict
+// `=== true`, so `uniqueItems: "yes"`, the shape a form encoding or a loose
+// YAML loader produces, drops to nothing the same way.
+//
+// A validator that quietly enforces LESS than its document says cannot be
+// detected downstream: it answers "valid" for exactly the inputs the schema
+// meant to refuse, and nothing in the result says a constraint went missing.
+// Build time is therefore the only place a caller can still act, so these
+// read the value and refuse it there.
+//
+// What must survive the refusal, because Draft-07 defines it: `items` has TWO
+// legal forms — one schema for every element, or an ARRAY of schemas where
+// position i constrains element i (§9.3.1) — `additionalItems` and `contains`
+// take the boolean form of a schema as readily as the object form (§4.4), and
+// `uniqueItems: false` is a lawful no-op (§6.4.3), so only a NON-boolean is
+// refused.
+// ===========================================================================
+import { isArray } from "../types/index.mjs";
+import { isDraft07Schema } from "./draft07.types.mjs";
+import { MalformedSchemaError, SCHEMA_FORMS } from "./malformed-schema-error.mjs";
+const ITEMS_REASON = "the value must be a schema or an array of schemas";
+const UNIQUE_ITEMS_REASON = "the value must be a boolean";
+/**
+ * Reads `items` after checking it against the meta-schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal when it is
+ * neither of the two forms §9.3.1 defines.
+ */
+export function readCheckedItems(schema) {
+    const items = schema.items;
+    if (items === undefined)
+        return undefined;
+    if (isArray(items))
+        return checkTuplePositions(items);
+    if (!isDraft07Schema(items)) {
+        throw new MalformedSchemaError("items", ITEMS_REASON, items);
+    }
+    return items;
+}
+/**
+ * Every position of the tuple form is a schema in its own right, so a bad one
+ * names its index: with the whole array rendered instead, a caller holding a
+ * long tuple is told only that something in it is wrong.
+ */
+function checkTuplePositions(positions) {
+    for (let index = 0; index < positions.length; index += 1) {
+        const position = positions[index];
+        if (isDraft07Schema(position))
+            continue;
+        throw new MalformedSchemaError("items", `position ${String(index)} of the array form ${SCHEMA_FORMS}`, position);
+    }
+    return positions;
+}
+/**
+ * Reads `additionalItems` after checking it is a single schema: the keyword's
+ * own value, or undefined when the keyword is absent, and a refusal for
+ * anything §4.4 does not call a schema.
+ *
+ * It is read only where §6.4.2 gives the keyword effect, which is beside the
+ * tuple form of `items`; beside the single form the draft ignores it, no rest
+ * branch is built and this reader is never reached.
+ */
+export function readCheckedAdditionalItems(schema) {
+    const additionalItems = schema.additionalItems;
+    if (additionalItems === undefined)
+        return undefined;
+    if (!isDraft07Schema(additionalItems)) {
+        throw new MalformedSchemaError("additionalItems", `the value ${SCHEMA_FORMS}`, additionalItems);
+    }
+    return additionalItems;
+}
+/**
+ * Reads `contains` after checking it is a single schema: the keyword's own
+ * value, or undefined when the keyword is absent, and a refusal for anything
+ * §4.4 does not call a schema. Unlike `items`, `contains` has no array form —
+ * a tuple there is a malformed value, not a second reading.
+ */
+export function readCheckedContains(schema) {
+    const contains = schema.contains;
+    if (contains === undefined)
+        return undefined;
+    if (!isDraft07Schema(contains)) {
+        throw new MalformedSchemaError("contains", `the value ${SCHEMA_FORMS}`, contains);
+    }
+    return contains;
+}
+/**
+ * Reads `uniqueItems` after checking it is a boolean: the keyword's own value,
+ * or undefined when the keyword is absent, and a refusal for anything else.
+ */
+export function readCheckedUniqueItems(schema) {
+    const uniqueItems = schema.uniqueItems;
+    if (uniqueItems === undefined)
+        return undefined;
+    if (typeof uniqueItems !== "boolean") {
+        throw new MalformedSchemaError("uniqueItems", UNIQUE_ITEMS_REASON, uniqueItems);
+    }
+    return uniqueItems;
+}

package/dist/json-schema/assert-object-keyword-values.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `required` is an array of property names (§6.5.3), and whatever the document
+ * put there is refused when it is anything else.
+ *
+ * UNIQUENESS IS NOT ENFORCED, although the meta-schema's `stringArray` asks
+ * for it. A repeated name asks for nothing the single name does not — the
+ * property is required either way, so the verdict is identical — and this
+ * check exists to stop a validator enforcing LESS than its document, not to
+ * lint a document that is enforced exactly as written. Refusing a duplicate
+ * would reject working schemas for no gain in correctness.
+ */
+export declare function assertRequiredIsNameList(value: unknown): void;
+/**
+ * `properties` maps property names to schemas (§6.5.4), and a schema is an
+ * object or a boolean; the map itself and every member of it are refused when
+ * they are not. The key is named in the reason so the message points at the
+ * offending node rather than at the whole document.
+ */
+export declare function assertPropertiesIsSchemaMap(value: unknown): void;
+/**
+ * `additionalProperties` is a schema, and §4.4 makes a boolean one (§6.5.6).
+ * Both of those forms pass through unchanged; only a value the meta-schema
+ * already forbids — a string, a number, an array, null — is refused.
+ */
+export declare function assertAdditionalPropertiesIsSchema(value: unknown): void;
+/**
+ * `patternProperties` maps regular expressions to schemas (§6.5.5). The map
+ * itself and every member of it are refused when they are not schemas, and the
+ * pattern is named in the reason so the message points at the one offending
+ * entry rather than at a map that may hold a dozen.
+ *
+ * THE KEYS ARE DELIBERATELY NOT COMPILED HERE, although Draft-07 says each
+ * SHOULD be a valid ECMA-262 pattern. A key that will not compile is not the
+ * failure this module exists to stop: the plugin compiles every key while
+ * building its rule, so such a key already kills the build, loudly, before any
+ * validator exists — it is a SyntaxError rather than a typed refusal, but
+ * nothing is silently under-enforced. Compiling one here as well would put a
+ * SECOND `new RegExp` in the converter, which holds exactly one — the `pattern`
+ * keyword's, over the document's own source string — so that regex
+ * construction and its flag handling stay in a single place.
+ */
+export declare function assertPatternPropertiesIsSchemaMap(value: unknown): void;
+/**
+ * `propertyNames` is ONE schema, applied to every property name (§6.5.8), and
+ * §4.4 makes a boolean one. An ARRAY is the shape of a schema list and is not
+ * itself a schema, so it is refused along with every primitive. An object
+ * stands whatever keywords it carries, because §4.3 has a schema ignore the
+ * keywords it does not recognise rather than be invalid for holding them.
+ */
+export declare function assertPropertyNamesIsSchema(value: unknown): void;
+/**
+ * `dependencies` maps a property name to what its presence demands (§6.5.7),
+ * and the draft gives that two equally lawful forms under the same key: an
+ * ARRAY of property names, which makes those names required alongside it, or a
+ * SCHEMA the whole instance must then satisfy. Both are kept; only a value
+ * that is neither is refused, and the key is named so the message points at
+ * the one offending entry rather than at the whole map.
+ */
+export declare function assertDependenciesIsSchemaOrNameListMap(value: unknown): void;

package/dist/json-schema/assert-object-keyword-values.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRequiredIsNameList = assertRequiredIsNameList;
+exports.assertPropertiesIsSchemaMap = assertPropertiesIsSchemaMap;
+exports.assertAdditionalPropertiesIsSchema = assertAdditionalPropertiesIsSchema;
+exports.assertPatternPropertiesIsSchemaMap = assertPatternPropertiesIsSchemaMap;
+exports.assertPropertyNamesIsSchema = assertPropertyNamesIsSchema;
+exports.assertDependenciesIsSchemaOrNameListMap = assertDependenciesIsSchemaOrNameListMap;
+// ===========================================================================
+// L8  src/json-schema/assert-object-keyword-values.ts — the meta-schema check
+// on the VALUES of the object-family keywords: `required`, `properties`,
+// `additionalProperties`, `patternProperties`, `propertyNames` and
+// `dependencies`.
+//
+// They live together because they fail together: every one is read in a place
+// that trusts the declared type, and untyped JSON reaches all six. `required:
+// "name"` is iterated as a string and declares one phantom child per
+// CHARACTER; `properties: {a: null}` is read for a pointer; the remaining four
+// take the sub-schema route with a value that is not a schema at all, and the
+// walker finds no keys on a primitive, so it yields a branch holding no rules.
+//
+// That last outcome is the SILENT one, and it is the one that matters most: a
+// document saying "no extra properties", or "every key beginning with a_ holds
+// a string", compiles to a validator that accepts everything. It is what a
+// config service serialising booleans as strings produces, and what a
+// hand-edited document with a quoted sub-schema produces. The loud failures
+// are loud in the wrong place — a raw TypeError read off null somewhere deep
+// in the walker, naming neither the keyword nor the document.
+//
+// Refusal is therefore always at BUILD time, and every well-formed shape is
+// untouched: a name list, a map of schemas (including the §4.4 boolean form),
+// a single schema, and — under `dependencies` — either a schema or an array of
+// property names, which §6.5.7 makes equally lawful under the same key.
+// ===========================================================================
+const types_1 = require("../types");
+const draft07_types_1 = require("./draft07.types");
+const malformed_schema_error_1 = require("./malformed-schema-error");
+/**
+ * `required` is an array of property names (§6.5.3), and whatever the document
+ * put there is refused when it is anything else.
+ *
+ * UNIQUENESS IS NOT ENFORCED, although the meta-schema's `stringArray` asks
+ * for it. A repeated name asks for nothing the single name does not — the
+ * property is required either way, so the verdict is identical — and this
+ * check exists to stop a validator enforcing LESS than its document, not to
+ * lint a document that is enforced exactly as written. Refusing a duplicate
+ * would reject working schemas for no gain in correctness.
+ */
+function assertRequiredIsNameList(value) {
+    if (value === undefined || (0, types_1.isStringArray)(value))
+        return;
+    throw new malformed_schema_error_1.MalformedSchemaError("required", "the value must be an array of property names", value);
+}
+/**
+ * `properties` and `patternProperties` differ only in what their KEYS mean, so
+ * they are checked the same way: the map itself, then every member of it, and
+ * the offending key named in the reason so the message points at one entry
+ * rather than at a map that may hold a dozen. `dependencies` is not routed
+ * through here — §6.5.7 gives its members a second lawful form, which is a
+ * different member check and a different sentence.
+ *
+ * `mapReason` is the keyword's own, because "an object mapping property names
+ * to schemas" and "an object mapping regular expressions to schemas" are the
+ * only part of the requirement the two keywords do not share.
+ */
+function assertSchemaMap(keyword, mapReason, value) {
+    if (value === undefined)
+        return;
+    if (!(0, types_1.isPlainObject)(value)) {
+        throw new malformed_schema_error_1.MalformedSchemaError(keyword, mapReason, value);
+    }
+    for (const [key, member] of Object.entries(value)) {
+        if ((0, draft07_types_1.isDraft07Schema)(member))
+            continue;
+        throw new malformed_schema_error_1.MalformedSchemaError(keyword, `the schema under "${key}" ${malformed_schema_error_1.SCHEMA_FORMS}`, member);
+    }
+}
+/**
+ * `properties` maps property names to schemas (§6.5.4), and a schema is an
+ * object or a boolean; the map itself and every member of it are refused when
+ * they are not. The key is named in the reason so the message points at the
+ * offending node rather than at the whole document.
+ */
+function assertPropertiesIsSchemaMap(value) {
+    assertSchemaMap("properties", "the value must be an object mapping property names to schemas", value);
+}
+/**
+ * `additionalProperties` is a schema, and §4.4 makes a boolean one (§6.5.6).
+ * Both of those forms pass through unchanged; only a value the meta-schema
+ * already forbids — a string, a number, an array, null — is refused.
+ */
+function assertAdditionalPropertiesIsSchema(value) {
+    if (value === undefined || (0, draft07_types_1.isDraft07Schema)(value))
+        return;
+    throw new malformed_schema_error_1.MalformedSchemaError("additionalProperties", `the value ${malformed_schema_error_1.SCHEMA_FORMS}`, value);
+}
+/**
+ * `patternProperties` maps regular expressions to schemas (§6.5.5). The map
+ * itself and every member of it are refused when they are not schemas, and the
+ * pattern is named in the reason so the message points at the one offending
+ * entry rather than at a map that may hold a dozen.
+ *
+ * THE KEYS ARE DELIBERATELY NOT COMPILED HERE, although Draft-07 says each
+ * SHOULD be a valid ECMA-262 pattern. A key that will not compile is not the
+ * failure this module exists to stop: the plugin compiles every key while
+ * building its rule, so such a key already kills the build, loudly, before any
+ * validator exists — it is a SyntaxError rather than a typed refusal, but
+ * nothing is silently under-enforced. Compiling one here as well would put a
+ * SECOND `new RegExp` in the converter, which holds exactly one — the `pattern`
+ * keyword's, over the document's own source string — so that regex
+ * construction and its flag handling stay in a single place.
+ */
+function assertPatternPropertiesIsSchemaMap(value) {
+    assertSchemaMap("patternProperties", "the value must be an object mapping regular expressions to schemas", value);
+}
+/**
+ * `propertyNames` is ONE schema, applied to every property name (§6.5.8), and
+ * §4.4 makes a boolean one. An ARRAY is the shape of a schema list and is not
+ * itself a schema, so it is refused along with every primitive. An object
+ * stands whatever keywords it carries, because §4.3 has a schema ignore the
+ * keywords it does not recognise rather than be invalid for holding them.
+ */
+function assertPropertyNamesIsSchema(value) {
+    if (value === undefined || (0, draft07_types_1.isDraft07Schema)(value))
+        return;
+    throw new malformed_schema_error_1.MalformedSchemaError("propertyNames", `the value ${malformed_schema_error_1.SCHEMA_FORMS}`, value);
+}
+/**
+ * `dependencies` maps a property name to what its presence demands (§6.5.7),
+ * and the draft gives that two equally lawful forms under the same key: an
+ * ARRAY of property names, which makes those names required alongside it, or a
+ * SCHEMA the whole instance must then satisfy. Both are kept; only a value
+ * that is neither is refused, and the key is named so the message points at
+ * the one offending entry rather than at the whole map.
+ */
+function assertDependenciesIsSchemaOrNameListMap(value) {
+    if (value === undefined)
+        return;
+    if (!(0, types_1.isPlainObject)(value)) {
+        throw new malformed_schema_error_1.MalformedSchemaError("dependencies", "the value must be an object mapping property names to schemas or to " +
+            "arrays of property names", value);
+    }
+    for (const [key, dependency] of Object.entries(value)) {
+        if ((0, types_1.isStringArray)(dependency) || (0, draft07_types_1.isDraft07Schema)(dependency))
+            continue;
+        throw new malformed_schema_error_1.MalformedSchemaError("dependencies", `the dependency under "${key}" ${malformed_schema_error_1.SCHEMA_FORMS}, or an array of ` +
+            "property names", dependency);
+    }
+}