@lovrozagar/oat 0.2.1 → 0.3.0

package/dist/runtime/fixture.js

@@ -5,6 +5,10 @@
  * order, escaping needs metacharacters. oat seeds a *discriminating cohort* — instances shaped so
  * that every query assertion has signal — and derives everything from a seed so a failing run is
  * exactly reproducible.
+ *
+ * After `$ref` inlining the same object identity can cycle, and empty schemas (`{}`, `true`,
+ * `additionalProperties: {}`) mean "any value", not "walk this object again". Generation therefore
+ * keys a WeakSet on every node and treats those open shapes as a scalar or `{}`.
  */
 export const COHORT = [
     "baseline",
@@ -34,97 +38,230 @@ const STRINGS = {
     "null-heavy": "null heavy record",
     unicode: "日本語 café ñandú",
 };
-export function buildCohort(bodySchema, seed, variants = COHORT) {
-    return variants.map((variant, index) => ({
-        body: generateObject(bodySchema, variant, mulberry32(seed + index * 7919), index),
-        variant,
-    }));
-}
-function generateObject(schema, variant, rand, index, depth = 0) {
-    if (depth > 4)
-        return {};
-    const properties = schema.properties;
-    if (properties === null || typeof properties !== "object")
-        return {};
-    const required = Array.isArray(schema.required) ? schema.required : [];
-    const out = {};
-    for (const [name, raw] of Object.entries(properties)) {
-        if (raw === null || typeof raw !== "object")
-            continue;
-        if (raw.readOnly === true)
-            continue;
-        const value = generateValue(name, raw, variant, rand, index, depth);
-        if (value === undefined) {
-            if (required.includes(name))
-                out[name] = fallbackFor(raw);
-            continue;
+const EMAIL_RE = /^[^@]+@[^@]+\.[^@]+$/;
+const MAX_DEPTH = 8;
+const PATTERN_ATTEMPTS = 48;
+/** Thrown when a walk still overflows; the pointer names the node that blew the stack. */
+export class FixtureOverflow extends Error {
+    operationId;
+    pointer;
+    constructor(operationId, pointer) {
+        super(`fixture generation overflow on ${operationId} (${pointer})`);
+        this.operationId = operationId;
+        this.pointer = pointer;
+        this.name = "FixtureOverflow";
+    }
+}
+export function overflowFrom(error, operationId, pointer = "/") {
+    if (error instanceof FixtureOverflow) {
+        return new FixtureOverflow(operationId, error.pointer === "/" ? pointer : error.pointer);
+    }
+    return new FixtureOverflow(operationId, pointer);
+}
+export function isOverflowError(error) {
+    if (error instanceof FixtureOverflow)
+        return true;
+    return error instanceof RangeError;
+}
+export function buildCohort(bodySchema, seed, variants = COHORT, operationId = "unknown") {
+    try {
+        return variants.map((variant, index) => ({
+            body: generateObject(bodySchema, variant, mulberry32(seed + index * 7919), index, 0, "/", new WeakSet(), operationId),
+            variant,
+        }));
+    }
+    catch (error) {
+        if (isOverflowError(error))
+            throw overflowFrom(error, operationId);
+        throw error;
+    }
+}
+/**
+ * One create body, or a gap if a required field cannot be honoured.
+ *
+ * Optional fields that cannot match `format`/`pattern` are omitted. Required ones must not fall
+ * back to `"Quarterly Report N"` — that is what 400s every email/handle/url field.
+ */
+export function generateBody(bodySchema, variant, rand, index, operationId = "unknown") {
+    const missingRequired = [];
+    const body = generateObject(bodySchema, variant, rand, index, 0, "/", new WeakSet(), operationId, missingRequired);
+    return { body, missingRequired };
+}
+function generateObject(schema, variant, rand, index, depth, pointer, seen, operationId, missingRequired = []) {
+    try {
+        if (depth > MAX_DEPTH)
+            return {};
+        if (isVacuous(schema))
+            return {};
+        if (schema === false)
+            return {};
+        if (typeof schema !== "object" || schema === null)
+            return {};
+        if (seen.has(schema))
+            return {};
+        seen.add(schema);
+        const concrete = concreteBranch(schema, depth, pointer, seen, operationId);
+        if (isVacuous(concrete) || typeof concrete !== "object" || concrete === null)
+            return {};
+        if (seen.has(concrete) && concrete !== schema)
+            return {};
+        const properties = concrete.properties;
+        if (properties === null || typeof properties !== "object")
+            return {};
+        const required = Array.isArray(concrete.required) ? concrete.required : [];
+        const out = {};
+        for (const [name, raw] of Object.entries(properties)) {
+            const child = `${pointer === "/" ? "" : pointer}/${escapePointer(name)}`;
+            const value = generateValue(name, raw, variant, rand, index, depth + 1, child, seen, operationId);
+            if (value === undefined) {
+                if (required.includes(name)) {
+                    const fallback = requiredFallback(raw, variant, index);
+                    if (fallback === undefined)
+                        missingRequired.push(child);
+                    else
+                        out[name] = fallback;
+                }
+                continue;
+            }
+            out[name] = value;
         }
-        out[name] = value;
+        return out;
+    }
+    catch (error) {
+        if (isOverflowError(error))
+            throw overflowFrom(error, operationId, pointer);
+        throw error;
     }
-    return out;
 }
-function generateValue(name, schema, variant, rand, index, depth = 0) {
-    /* Recursive schemas are shared objects after dereferencing, so generation must be bounded. */
-    if (depth > 4)
-        return undefined;
-    const nullable = isNullable(schema);
-    if (variant === "null-heavy" && nullable)
-        return null;
-    const concrete = concreteBranch(schema);
-    const type = typeOf(concrete);
-    if (Array.isArray(concrete.enum) && concrete.enum.length > 0) {
-        /* Walk the enum across the cohort so every value is represented and filters on it
-         * partition the set non-trivially. */
-        return concrete.enum[index % concrete.enum.length];
-    }
-    switch (type) {
-        case "string": {
-            const max = typeof concrete.maxLength === "number" ? concrete.maxLength : 64;
-            if (variant === "boundary")
-                return "B".repeat(Math.max(1, Math.min(max, 512)));
-            const base = STRINGS[variant];
-            /* Suffix keeps values distinct so equality filters select exactly one instance. */
-            const text = `${base} ${index}`;
-            return text.length > max ? text.slice(0, max) : text;
+function generateValue(name, raw, variant, rand, index, depth, pointer, seen, operationId) {
+    try {
+        if (depth > MAX_DEPTH)
+            return undefined;
+        if (isVacuous(raw))
+            return scalarFor(name, variant, index, undefined);
+        if (raw === false)
+            return undefined;
+        if (typeof raw !== "object" || raw === null)
+            return undefined;
+        if (seen.has(raw))
+            return {};
+        const schema = raw;
+        const nullable = isNullable(schema);
+        if (variant === "null-heavy" && nullable)
+            return null;
+        if (schema.readOnly === true)
+            return undefined;
+        const followed = followRef(schema, depth, pointer, seen, operationId);
+        if (followed === "cycle")
+            return {};
+        const concrete = concreteBranch(followed === null ? schema : followed, depth, pointer, seen, operationId);
+        if (isVacuous(concrete))
+            return scalarFor(name, variant, index, undefined);
+        if (typeof concrete !== "object" || concrete === null)
+            return scalarFor(name, variant, index, undefined);
+        if (seen.has(concrete) && concrete !== schema)
+            return {};
+        if (Array.isArray(concrete.enum) && concrete.enum.length > 0) {
+            return concrete.enum[index % concrete.enum.length];
         }
-        case "integer":
-        case "number": {
-            if (variant === "boundary" && typeof concrete.maximum === "number")
-                return concrete.maximum;
-            const min = typeof concrete.minimum === "number" ? concrete.minimum : 0;
-            /*
-             * A ladder whose lexical order differs from its numeric order: as text these sort
-             * 1, 10, 100, 2, 20, 5, 50 — nothing like their numeric order.
-             *
-             * An evenly spaced sequence (10, 20, 30…) sorts identically either way, so a backend
-             * comparing numbers as strings would look correct. Values have to disagree for the
-             * assertion to carry any signal.
-             */
-            const ladder = [1, 2, 5, 10, 20, 50, 100];
-            const step = ladder[index % ladder.length] ?? 1;
-            return type === "integer" ? min + step : min + step + Math.round(rand() * 9) / 10;
+        const type = typeOf(concrete);
+        switch (type) {
+            case "string":
+                return generateString(name, concrete, variant, index);
+            case "integer":
+            case "number": {
+                if (variant === "boundary" && typeof concrete.maximum === "number")
+                    return concrete.maximum;
+                const min = typeof concrete.minimum === "number" ? concrete.minimum : 0;
+                /*
+                 * A ladder whose lexical order differs from its numeric order: as text these sort
+                 * 1, 10, 100, 2, 20, 5, 50 — nothing like their numeric order.
+                 *
+                 * An evenly spaced sequence (10, 20, 30…) sorts identically either way, so a backend
+                 * comparing numbers as strings would look correct. Values have to disagree for the
+                 * assertion to carry any signal.
+                 */
+                const ladder = [1, 2, 5, 10, 20, 50, 100];
+                const step = ladder[index % ladder.length] ?? 1;
+                return type === "integer" ? min + step : min + step + Math.round(rand() * 9) / 10;
+            }
+            case "boolean":
+                return index % 2 === 0;
+            case "array": {
+                /* An empty array is not a safe default: `minItems` is common on required collections
+                 * (column definitions, line items), and sending [] fails validation on exactly the
+                 * endpoints most worth testing. */
+                const min = typeof concrete.minItems === "number" ? concrete.minItems : 0;
+                const count = Math.max(min, 1);
+                const prefix = concrete.prefixItems;
+                if (Array.isArray(prefix)) {
+                    return prefix.map((item, position) => generateValue(`${name}_${position}`, item, variant, rand, index + position, depth + 1, `${pointer}/prefixItems/${position}`, seen, operationId));
+                }
+                const items = concrete.items;
+                if (isVacuous(items) || items === false)
+                    return Array.from({ length: count }, () => ({}));
+                if (items === null || typeof items !== "object")
+                    return [];
+                return Array.from({ length: count }, (_, position) => generateValue(`${name}_item`, items, variant, rand, index + position, depth + 1, `${pointer}/items`, seen, operationId));
+            }
+            case "object":
+                return generateObject(concrete, variant, rand, index, depth + 1, pointer, seen, operationId);
+            default:
+                return undefined;
         }
-        case "boolean":
-            return index % 2 === 0;
-        case "array": {
-            /* An empty array is not a safe default: `minItems` is common on required collections
-             * (column definitions, line items), and sending [] fails validation on exactly the
-             * endpoints most worth testing. */
-            const min = typeof concrete.minItems === "number" ? concrete.minItems : 0;
-            const count = Math.max(min, 1);
-            const items = concrete.items;
-            if (items === null || typeof items !== "object")
-                return [];
-            return Array.from({ length: count }, (_, position) => generateValue(`${name}_item`, items, variant, rand, index + position, depth + 1));
+    }
+    catch (error) {
+        if (isOverflowError(error))
+            throw overflowFrom(error, operationId, pointer);
+        throw error;
+    }
+}
+function generateString(name, schema, variant, index) {
+    const max = typeof schema.maxLength === "number" ? schema.maxLength : 64;
+    const format = typeof schema.format === "string" ? schema.format.toLowerCase() : "";
+    const pattern = typeof schema.pattern === "string" ? schema.pattern : undefined;
+    let text;
+    if (format === "email")
+        text = emailOf(variant, index);
+    else if (format === "uri" || format === "url")
+        text = uriOf(variant, index);
+    else if (format === "uuid")
+        text = uuidOf(variant, index);
+    else if (pattern !== undefined)
+        text = stringMatching(pattern, max, variant, index);
+    else if (variant === "boundary")
+        text = "B".repeat(Math.max(1, Math.min(max, 512)));
+    else {
+        const base = STRINGS[variant];
+        text = `${base} ${index}`;
+    }
+    if (text === undefined)
+        return undefined;
+    if (text.length > max) {
+        if (format === "email" || format === "uri" || format === "url" || format === "uuid" || pattern !== undefined) {
+            const trimmed = fitMax(text, max, format, pattern, variant, index);
+            return trimmed;
         }
-        case "object":
-            return generateObject(concrete, variant, rand, index, depth + 1);
-        default:
-            return undefined;
+        return text.slice(0, max);
     }
+    if (pattern !== undefined && !safeTest(pattern, text)) {
+        return stringMatching(pattern, max, variant, index);
+    }
+    if (format === "email" && !EMAIL_RE.test(text))
+        return undefined;
+    void name;
+    return text;
 }
-function fallbackFor(schema) {
-    switch (typeOf(concreteBranch(schema))) {
+function requiredFallback(raw, variant, index) {
+    if (isVacuous(raw) || raw === false || raw === null || typeof raw !== "object")
+        return scalarFor("field", variant, index, undefined);
+    const schema = raw;
+    const format = typeof schema.format === "string" ? schema.format.toLowerCase() : "";
+    const pattern = typeof schema.pattern === "string" ? schema.pattern : undefined;
+    if (format === "email" || format === "uri" || format === "url" || format === "uuid" || pattern !== undefined) {
+        return generateString("field", schema, variant, index);
+    }
+    switch (typeOf(concreteBranch(schema, 0, "/", new WeakSet(), "unknown"))) {
         case "integer":
         case "number":
             return 0;
@@ -135,16 +272,327 @@ function fallbackFor(schema) {
         case "object":
             return {};
         default:
-            return "value";
+            return generateString("field", schema, variant, index) ?? "value";
+    }
+}
+function emailOf(variant, index) {
+    const slug = slugVariant(variant);
+    return `oat-${slug}-${index}@example.test`;
+}
+function uriOf(variant, index) {
+    return `https://example.test/${slugVariant(variant)}-${index}`;
+}
+function uuidOf(variant, index) {
+    const n = (slugVariant(variant).length * 17 + index * 7919) >>> 0;
+    const hex = (offset, width) => {
+        let out = "";
+        let x = (n + offset * 0x9e3779b9) >>> 0;
+        for (let i = 0; i < width; i++) {
+            out += (x & 0xf).toString(16);
+            x = (Math.imul(x, 1664525) + 1013904223) >>> 0;
+        }
+        return out;
+    };
+    return `${hex(1, 8)}-${hex(2, 4)}-4${hex(3, 3)}-8${hex(4, 3)}-${hex(5, 12)}`;
+}
+function slugVariant(variant) {
+    return variant
+        .replace(/[^a-z0-9]+/gi, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+}
+function fitMax(text, max, format, pattern, variant, index) {
+    if (format === "email") {
+        const short = `o${index}@e.t`;
+        if (short.length <= max && EMAIL_RE.test(short))
+            return short;
+        return undefined;
+    }
+    if (format === "uri" || format === "url") {
+        const short = "https://e.t/x";
+        if (short.length <= max)
+            return short;
+        return undefined;
+    }
+    if (format === "uuid")
+        return undefined;
+    if (pattern !== undefined)
+        return stringMatching(pattern, max, variant, index);
+    return text.slice(0, max);
+}
+/** Bounded attempt at a string the documented regex will accept. */
+function stringMatching(pattern, max, variant, index) {
+    const candidates = [
+        expandPattern(pattern, max, variant, index),
+        emailOf(variant, index),
+        uriOf(variant, index),
+        uuidOf(variant, index),
+        slugVariant(variant),
+        `oat${index}`,
+        `h${index}`,
+        "a",
+        "ab",
+        "abc",
+        "handle",
+        `handle${index}`,
+        "https://example.test/x",
+        "oat@example.test",
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined)
+            continue;
+        const text = candidate.length > max ? candidate.slice(0, max) : candidate;
+        if (text.length <= max && safeTest(pattern, text))
+            return text;
+    }
+    for (let attempt = 0; attempt < PATTERN_ATTEMPTS; attempt++) {
+        const text = brutePattern(pattern, max, variant, index + attempt);
+        if (text !== undefined && safeTest(pattern, text))
+            return text;
+    }
+    return undefined;
+}
+function safeTest(pattern, text) {
+    try {
+        return new RegExp(pattern).test(text);
+    }
+    catch {
+        return false;
     }
 }
+/**
+ * Expand a small, common subset of regexes (`[a-z0-9_]+`, `^handle$`, optional groups). Anything
+ * we cannot expand is left for the candidate list — better to omit than to send a junk string.
+ */
+function expandPattern(pattern, max, variant, index) {
+    let source = pattern;
+    if (source.startsWith("^"))
+        source = source.slice(1);
+    if (source.endsWith("$"))
+        source = source.slice(0, -1);
+    try {
+        const built = expandAtoms(source, max, variant, index);
+        if (built.length > max)
+            return built.slice(0, max);
+        return built;
+    }
+    catch {
+        return undefined;
+    }
+}
+function expandAtoms(source, max, variant, index) {
+    let i = 0;
+    let out = "";
+    const takeQuantifier = () => {
+        if (source[i] === "+") {
+            i++;
+            return { max: 3, min: 1 };
+        }
+        if (source[i] === "*") {
+            i++;
+            return { max: 2, min: 0 };
+        }
+        if (source[i] === "?") {
+            i++;
+            return { max: 1, min: 0 };
+        }
+        if (source[i] === "{") {
+            const close = source.indexOf("}", i);
+            if (close < 0)
+                return { max: 1, min: 1 };
+            const spec = source.slice(i + 1, close);
+            i = close + 1;
+            const [lo, hi] = spec.split(",");
+            const min = Number.parseInt(lo ?? "1", 10);
+            const upper = hi === undefined ? min : hi === "" ? min + 2 : Number.parseInt(hi, 10);
+            if (!Number.isFinite(min) || !Number.isFinite(upper))
+                return { max: 1, min: 1 };
+            return { max: Math.min(upper, 16), min: Math.max(0, min) };
+        }
+        return { max: 1, min: 1 };
+    };
+    const emit = (atom, times) => {
+        for (let n = 0; n < times && out.length < max; n++)
+            out += atom;
+    };
+    while (i < source.length && out.length < max) {
+        const ch = source[i];
+        if (ch === undefined)
+            break;
+        if (ch === "(") {
+            const close = matchingParen(source, i);
+            if (close < 0)
+                break;
+            const inner = source.slice(i + 1, close).replace(/^\?:/, "");
+            i = close + 1;
+            const q = takeQuantifier();
+            const piece = expandAtoms(inner.split("|")[0] ?? inner, max, variant, index);
+            emit(piece, Math.max(q.min, Math.min(q.max, q.min === 0 ? 0 : 1)));
+            continue;
+        }
+        if (ch === "[") {
+            const close = source.indexOf("]", i + 1);
+            if (close < 0)
+                break;
+            const atom = firstClassChar(source.slice(i + 1, close));
+            i = close + 1;
+            const q = takeQuantifier();
+            emit(atom, Math.max(q.min, 1));
+            continue;
+        }
+        if (ch === "\\") {
+            const next = source[i + 1];
+            i += 2;
+            const atom = next === "d" ? "0" : next === "w" ? "a" : next === "s" ? " " : (next ?? "a");
+            const q = takeQuantifier();
+            emit(atom, Math.max(q.min, 1));
+            continue;
+        }
+        if (ch === ".") {
+            i++;
+            const q = takeQuantifier();
+            emit("a", Math.max(q.min, 1));
+            continue;
+        }
+        if (ch === "|" || ch === ")" || ch === "^" || ch === "$") {
+            i++;
+            continue;
+        }
+        i++;
+        const q = takeQuantifier();
+        emit(ch, Math.max(q.min, 1));
+    }
+    void variant;
+    void index;
+    return out;
+}
+function matchingParen(source, start) {
+    let depth = 0;
+    for (let i = start; i < source.length; i++) {
+        if (source[i] === "(")
+            depth++;
+        else if (source[i] === ")") {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function firstClassChar(body) {
+    let i = 0;
+    if (body[0] === "^")
+        i = 1;
+    while (i < body.length) {
+        const ch = body[i];
+        if (ch === undefined)
+            break;
+        if (ch === "\\" && body[i + 1] !== undefined) {
+            const next = body[i + 1];
+            if (next === "d")
+                return "0";
+            if (next === "w")
+                return "a";
+            return next ?? "a";
+        }
+        if (body[i + 1] === "-" && body[i + 2] !== undefined) {
+            return ch === "^" ? (body[i + 2] ?? "a") : ch;
+        }
+        if (ch !== "^")
+            return ch;
+        i++;
+    }
+    return "a";
+}
+function brutePattern(pattern, max, variant, salt) {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789_-";
+    const len = Math.min(Math.max(3, (salt % 8) + 3), max);
+    let text = "";
+    let x = (salt * 1664525 + slugVariant(variant).length) >>> 0;
+    for (let i = 0; i < len; i++) {
+        text += alphabet[x % alphabet.length];
+        x = (Math.imul(x, 22695477) + 1) >>> 0;
+    }
+    return text;
+}
+function scalarFor(name, variant, index, schema) {
+    if (schema !== undefined) {
+        const generated = generateString(name, schema, variant, index);
+        if (generated !== undefined)
+            return generated;
+    }
+    const base = STRINGS[variant];
+    return `${base} ${index}`;
+}
+/**
+ * `{}` / `true` / a lone `additionalProperties: {}` is "any JSON", not an object to descend.
+ * Walking it again is what turns `z.unknown()` into a stack overflow.
+ */
+export function isVacuous(schema) {
+    if (schema === true)
+        return true;
+    if (schema === false || schema === null || typeof schema !== "object")
+        return false;
+    if (Array.isArray(schema))
+        return false;
+    const keys = Object.keys(schema).filter((key) => !isAnnotation(key));
+    if (keys.length === 0)
+        return true;
+    if (keys.length === 1 && (keys[0] === "additionalProperties" || keys[0] === "unevaluatedProperties")) {
+        return isVacuous(schema[keys[0]]);
+    }
+    if (keys.length === 1 && keys[0] === "default") {
+        const value = schema.default;
+        return (value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0);
+    }
+    return false;
+}
+function isAnnotation(key) {
+    return (key === "description" ||
+        key === "title" ||
+        key === "deprecated" ||
+        key === "example" ||
+        key === "examples" ||
+        key === "nullable" ||
+        key === "readOnly" ||
+        key === "writeOnly" ||
+        key === "xml" ||
+        key === "externalDocs");
+}
 /** `oneOf: [{type: string}, {type: null}]` is the nullable idiom; pick the non-null branch. */
-function concreteBranch(schema) {
-    const union = schema.oneOf ?? schema.anyOf;
+function concreteBranch(schema, depth, pointer, seen, operationId) {
+    if (depth > MAX_DEPTH)
+        return {};
+    const followed = followRef(schema, depth, pointer, seen, operationId);
+    const base = followed === "cycle" ? {} : (followed ?? schema);
+    if (typeof base !== "object" || base === null)
+        return {};
+    const union = base.oneOf ?? base.anyOf;
     if (!Array.isArray(union))
-        return schema;
-    const branch = union.find((candidate) => candidate !== null && typeof candidate === "object" && candidate.type !== "null");
-    return branch ?? schema;
+        return base;
+    const branch = union.find((candidate) => {
+        if (candidate === null || typeof candidate !== "object")
+            return candidate !== null;
+        return candidate.type !== "null";
+    });
+    if (branch === null || typeof branch !== "object")
+        return base;
+    if (seen.has(branch))
+        return {};
+    return concreteBranch(branch, depth + 1, `${pointer}/oneOf`, seen, operationId);
+}
+function followRef(schema, depth, pointer, seen, operationId) {
+    void pointer;
+    void operationId;
+    if (depth > MAX_DEPTH)
+        return "cycle";
+    const ref = schema.$ref;
+    if (typeof ref !== "string")
+        return null;
+    /* After inlining, leftover `$ref: "#"` (or any self-ref) is the same node. Do not follow. */
+    if (ref === "#" || ref === "#/" || seen.has(schema))
+        return "cycle";
+    return "cycle";
 }
 function isNullable(schema) {
     if (schema.nullable === true)
@@ -158,6 +606,16 @@ function isNullable(schema) {
     return union.some((candidate) => candidate !== null && typeof candidate === "object" && candidate.type === "null");
 }
 function typeOf(schema) {
+    if (isVacuous(schema))
+        return "string";
+    const add = schema.additionalProperties;
+    const uneval = schema.unevaluatedProperties;
+    if (schema.type === undefined &&
+        schema.properties === undefined &&
+        schema.items === undefined &&
+        (isVacuous(add) || isVacuous(uneval))) {
+        return "object";
+    }
     const type = schema.type;
     if (typeof type === "string")
         return type;
@@ -168,8 +626,11 @@ function typeOf(schema) {
     }
     if (schema.properties !== undefined)
         return "object";
-    if (schema.items !== undefined)
+    if (schema.items !== undefined || schema.prefixItems !== undefined)
         return "array";
     return "string";
 }
+function escapePointer(name) {
+    return name.replace(/~/g, "~0").replace(/\//g, "~1");
+}
 //# sourceMappingURL=fixture.js.map