@mionjs/run-types 0.13.0 → 0.14.0

package/dist/cjs/mocking/mockType.js

@@ -1,810 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockRunType = mockRunType;
-const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
-const mockRegistry_ts_1 = require("./mockRegistry.js");
-const childMatch_ts_1 = require("./childMatch.js");
-const structuralFormat_ts_1 = require("./structuralFormat.js");
-const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
-const mockRandom_ts_1 = require("./mockRandom.js");
-const constants_mock_ts_1 = require("./constants.mock.js");
-const mockDateTimeBounds_ts_1 = require("./mockDateTimeBounds.js");
-const mockTemporal_ts_1 = require("./mockTemporal.js");
-const mockStringFormat_ts_1 = require("./mockStringFormat.js");
-function mockRunType(runType, options, stack = []) {
-    stack.push(runType);
-    try {
-        const baseMockOpts = options.mock;
-        const nestLevel = countOccurrences(stack, runType);
-        if (nestLevel > baseMockOpts.maxMockRecursion)
-            return undefined;
-        const decayed = nestLevel > 1 ? decayOptionsForNesting(options, nestLevel) : options;
-        let mocked = mockSwitch(runType, decayed, stack);
-        if (runType.formatAnnotation && mocked !== undefined) {
-            const transform = lookupFormatTransform(runType.id);
-            if (transform)
-                mocked = transform(mocked);
-        }
-        return mocked;
-    }
-    finally {
-        stack.pop();
-    }
-}
-const FORMAT_TRANSFORM_FAMILY = 'fmt';
-function lookupFormatTransform(id) {
-    const entry = (0, rtUtils_ts_1.getRTUtils)().findRTForType(FORMAT_TRANSFORM_FAMILY, id);
-    if (!entry || entry.isNoop || !entry.fn)
-        return undefined;
-    return entry.fn;
-}
-function countOccurrences(stack, target) {
-    let count = 0;
-    for (let i = 0; i < stack.length; i++) {
-        if (stack[i] === target)
-            count++;
-    }
-    return count;
-}
-function decayOptionsForNesting(options, nestLevel) {
-    const mOps = options.mock;
-    const maxDepth = mOps.maxMockRecursion;
-    const divisor = nestLevel;
-    const newProv = nestLevel >= maxDepth ? 0 : mOps.optionalProbability / divisor;
-    const newMaxLength = nestLevel >= maxDepth ? 0 : decayItemsLength(mOps.maxRandomItemsLength, nestLevel);
-    const next = {
-        ...mOps,
-        optionalProbability: newProv,
-        maxRandomItemsLength: newMaxLength,
-    };
-    if (mOps.optionalPropertyProbability) {
-        const entries = Object.entries(mOps.optionalPropertyProbability).map(([key, value]) => {
-            const decayed = nestLevel > maxDepth ? 0 : value / divisor;
-            return [key, decayed];
-        });
-        next.optionalPropertyProbability = Object.fromEntries(entries);
-    }
-    if (mOps.arrayLength !== undefined) {
-        next.arrayLength = nestLevel >= maxDepth ? 0 : decayItemsLength(mOps.arrayLength, nestLevel);
-    }
-    if (mOps.parentObj)
-        next.parentObj = {};
-    return { ...options, mock: next };
-}
-function decayItemsLength(length, nestLevel) {
-    return Math.round(length / nestLevel);
-}
-function isItemCollection(runType) {
-    const kind = runType.kind;
-    if (kind === runTypeKind_generated_ts_1.RunTypeKind.array || kind === runTypeKind_generated_ts_1.RunTypeKind.rest || kind === runTypeKind_generated_ts_1.RunTypeKind.indexSignature)
-        return true;
-    if (kind === runTypeKind_generated_ts_1.RunTypeKind.tupleMember || kind === runTypeKind_generated_ts_1.RunTypeKind.parameter) {
-        return Array.isArray(runType.flags) && runType.flags.includes('rest');
-    }
-    const subKind = runType.subKind;
-    return kind === runTypeKind_generated_ts_1.RunTypeKind.class && (subKind === runTypeKind_generated_ts_1.RunTypeSubKind.map || subKind === runTypeKind_generated_ts_1.RunTypeSubKind.set);
-}
-const COLLECTION_LEVEL_STEP = 2;
-function shrinkForNestedItems(options, stack) {
-    let nestLevel = 1;
-    for (let i = 0; i < stack.length; i++)
-        if (isItemCollection(stack[i]))
-            nestLevel += COLLECTION_LEVEL_STEP;
-    const mOps = options.mock;
-    return { ...options, mock: { ...mOps, maxRandomItemsLength: decayItemsLength(mOps.maxRandomItemsLength, nestLevel) } };
-}
-function withDataNode(options, next) {
-    if (options.dataNode === next)
-        return options;
-    return { ...options, dataNode: next };
-}
-function asDataNode(value) {
-    if (value && typeof value === 'object' && !Array.isArray(value))
-        return value;
-    return undefined;
-}
-function childDataNodeByName(node, name) {
-    if (!node || name === undefined)
-        return undefined;
-    return asDataNode(node[name]);
-}
-function dataPool(node) {
-    if (node && Array.isArray(node.pool) && node.pool.length > 0)
-        return node.pool;
-    return undefined;
-}
-function dataArrayLength(node, random) {
-    const len = node?.rt$length;
-    if (typeof len === 'number')
-        return len;
-    if (Array.isArray(len) && len.length === 2)
-        return random.int(len[0], len[1]);
-    return undefined;
-}
-const STRUCTURAL_MOCK_ATTEMPTS = 32;
-function mockSwitch(runType, options, stack) {
-    const structural = (0, structuralFormat_ts_1.isStructuralFormat)(runType.formatAnnotation) ? runType.formatAnnotation : undefined;
-    if (!structural)
-        return mockKindSwitch(runType, options, stack);
-    for (let attempt = 0; attempt < STRUCTURAL_MOCK_ATTEMPTS; attempt++) {
-        const attemptOptions = attempt < STRUCTURAL_MOCK_ATTEMPTS / 2
-            ? options
-            : { ...options, mock: { ...options.mock, arrayLength: attempt % 3 } };
-        const candidate = mockKindSwitch(runType, attemptOptions, stack);
-        if (!(0, structuralFormat_ts_1.structuralFormatAccepts)(candidate, structural))
-            continue;
-        return candidate;
-    }
-    throw new Error(`Cannot mock a structural format: ${STRUCTURAL_MOCK_ATTEMPTS} candidates all failed the ${String(runType.formatAnnotation?.name)} constraints. ` +
-        'Provide a MockData pool for this type (enrich) with values that satisfy them.');
-}
-function mockKindSwitch(runType, options, stack) {
-    const mOps = options.mock;
-    const random = mOps.random ?? mockRandom_ts_1.nativeMockRandom;
-    const kind = runType.kind;
-    const dataNode = options.dataNode;
-    const pool = dataPool(dataNode);
-    if (pool)
-        return random.pick(pool);
-    if (runType.formatAnnotation) {
-        const mockFn = (0, mockRegistry_ts_1.getMockingFunction)(kind);
-        if (mockFn) {
-            const mocked = mockFn(runType.formatAnnotation, random, mOps);
-            if (mocked !== undefined)
-                return mocked;
-        }
-    }
-    switch (kind) {
-        case runTypeKind_generated_ts_1.RunTypeKind.never:
-            throw new Error('Cannot mock never type.');
-        case runTypeKind_generated_ts_1.RunTypeKind.any:
-        case runTypeKind_generated_ts_1.RunTypeKind.unknown:
-            return random.any(mOps.anyValuesList);
-        case runTypeKind_generated_ts_1.RunTypeKind.string:
-            return random.string(mOps.stringLength ?? random.int(1, mOps.maxRandomStringLength), mOps.stringCharSet || constants_mock_ts_1.stringCharSet);
-        case runTypeKind_generated_ts_1.RunTypeKind.number: {
-            const min = typeof dataNode?.min === 'number' ? dataNode.min : mOps.minNumber;
-            const max = typeof dataNode?.max === 'number' ? dataNode.max : mOps.maxNumber;
-            return random.number(min, max);
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.boolean:
-            return random.boolean();
-        case runTypeKind_generated_ts_1.RunTypeKind.bigint:
-            return random.bigint(mOps.minNumber, mOps.maxNumber);
-        case runTypeKind_generated_ts_1.RunTypeKind.null:
-            return null;
-        case runTypeKind_generated_ts_1.RunTypeKind.undefined:
-            return undefined;
-        case runTypeKind_generated_ts_1.RunTypeKind.void:
-            return undefined;
-        case runTypeKind_generated_ts_1.RunTypeKind.regexp:
-            return mOps.nonDataTypes ? random.regExp(mOps.regexpList) : undefined;
-        case runTypeKind_generated_ts_1.RunTypeKind.symbol:
-            return random.symbol(mOps.symbolName, mOps.symbolLength, mOps.symbolCharSet);
-        case runTypeKind_generated_ts_1.RunTypeKind.literal:
-            return runType.literal;
-        case runTypeKind_generated_ts_1.RunTypeKind.object:
-            return random.pick(mOps.objectList);
-        case runTypeKind_generated_ts_1.RunTypeKind.enum: {
-            const values = runType.values;
-            if (!Array.isArray(values) || values.length === 0) {
-                throw new Error('Cannot mock enum without values.');
-            }
-            const index = mOps.enumIndex ?? random.int(0, values.length - 1);
-            return values[index];
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.enumMember:
-            throw new Error('Mock enum member is not supported.');
-        case runTypeKind_generated_ts_1.RunTypeKind.class: {
-            const subKind = runType.subKind;
-            if (subKind === runTypeKind_generated_ts_1.RunTypeSubKind.date) {
-                const dateParams = runType.formatAnnotation?.name === 'nativeDate' ? runType.formatAnnotation.params : undefined;
-                if (dateParams &&
-                    (dateParams.min !== undefined ||
-                        dateParams.max !== undefined ||
-                        dateParams.gt !== undefined ||
-                        dateParams.lt !== undefined)) {
-                    return (0, mockDateTimeBounds_ts_1.mockBoundedNativeDate)({
-                        min: dateParams.min,
-                        max: dateParams.max,
-                        gt: dateParams.gt,
-                        lt: dateParams.lt,
-                    }, random);
-                }
-                const minDate = dataNode?.min instanceof Date ? dataNode.min : mOps.minDate;
-                const maxDate = dataNode?.max instanceof Date ? dataNode.max : mOps.maxDate;
-                return random.date(minDate, maxDate);
-            }
-            if (subKind === runTypeKind_generated_ts_1.RunTypeSubKind.map)
-                return mockMap(runType, withDataNode(options, undefined), stack);
-            if (subKind === runTypeKind_generated_ts_1.RunTypeSubKind.set)
-                return mockSet(runType, withDataNode(options, undefined), stack);
-            if (subKind === runTypeKind_generated_ts_1.RunTypeSubKind.url)
-                return (0, mockStringFormat_ts_1.mockUrlObject)(runType.formatAnnotation, random);
-            if ((0, mockTemporal_ts_1.isTemporalSubKind)(subKind)) {
-                const bounds = (0, mockTemporal_ts_1.temporalBoundsFromAnnotation)(runType.formatAnnotation);
-                return (0, mockTemporal_ts_1.mockTemporal)(subKind, bounds, random);
-            }
-            if (subKind === runTypeKind_generated_ts_1.RunTypeSubKind.nonSerializable) {
-                if (mOps.nonDataTypes)
-                    return mockNonSerializableNative(runType);
-                throw new Error('Mock is disabled for non-serializable types.');
-            }
-            return buildObjectLiteral(runType, options, stack, mOps);
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.array: {
-            const child = runType.child;
-            if (!child)
-                throw new Error('Cannot mock array: child runtype missing.');
-            const annotation = runType.formatAnnotation;
-            const arrayParams = annotation?.name === 'formattedArray' ? (annotation.params ?? {}) : undefined;
-            const length = clampToItemBounds(arrayParams, dataArrayLength(dataNode, random) ?? mOps.arrayLength ?? random.int(0, mOps.maxRandomItemsLength));
-            const childOpts = withDataNode(shrinkForNestedItems(options, stack), asDataNode(dataNode?.rt$items));
-            const containsChecks = (runType.contains ?? []);
-            if (containsChecks.length > 0) {
-                const matchedByEntry = [];
-                for (const entry of containsChecks) {
-                    if (entry.max >= 0 && entry.min > entry.max) {
-                        throw new Error('Cannot mock contains: minContains exceeds maxContains — the schema is provably empty.');
-                    }
-                    const entryItems = [];
-                    for (let n = 0; n < entry.min; n++) {
-                        const item = mockRunType(entry.child, childOpts, stack);
-                        if (!(0, childMatch_ts_1.childSchemaMatches)(item, child)) {
-                            throw new Error('Cannot mock contains: the contains child and the items type are contradictory. ' +
-                                'Provide a MockData pool for this type (enrich).');
-                        }
-                        entryItems.push(item);
-                    }
-                    matchedByEntry.push(entryItems);
-                }
-                const matched = matchedByEntry.flat();
-                const items = [...matched];
-                let fillerAttempts = 0;
-                while (items.length < Math.max(length, matched.length) && fillerAttempts < 64) {
-                    fillerAttempts++;
-                    const filler = mockRunType(child, childOpts, stack);
-                    if (containsChecks.every((entry) => !(0, childMatch_ts_1.childSchemaMatches)(filler, entry.child)))
-                        items.push(filler);
-                }
-                if (arrayParams?.uniqueItems === true) {
-                    const seen = new Set();
-                    const unique = items.filter((item) => {
-                        const key = (0, structuralFormat_ts_1.canonicalJson)(item);
-                        if (seen.has(key))
-                            return false;
-                        seen.add(key);
-                        return true;
-                    });
-                    containsChecks.forEach((entry, index) => {
-                        const surviving = matchedByEntry[index].filter((item) => unique.includes(item)).length;
-                        if (surviving < entry.min) {
-                            throw new Error('Cannot mock contains with uniqueItems: the contains child cannot produce enough distinct values. ' +
-                                'Provide a MockData pool for this type (enrich).');
-                        }
-                    });
-                    return unique;
-                }
-                return items;
-            }
-            if (length === 0)
-                return [];
-            if (arrayParams?.uniqueItems === true) {
-                const seen = new Set();
-                const items = [];
-                let attempts = 0;
-                while (items.length < length && attempts < length * 32) {
-                    attempts++;
-                    const item = mockRunType(child, childOpts, stack);
-                    const key = (0, structuralFormat_ts_1.canonicalJson)(item);
-                    if (seen.has(key))
-                        continue;
-                    seen.add(key);
-                    items.push(item);
-                }
-                const minItems = typeof arrayParams.minItems === 'number' ? arrayParams.minItems : 0;
-                if (items.length < minItems) {
-                    throw new Error(`Cannot mock a uniqueItems array: the element type cannot produce ${minItems} distinct values. ` +
-                        'Provide a MockData pool for this type (enrich) with enough distinct samples.');
-                }
-                return items;
-            }
-            const items = [];
-            for (let i = 0; i < length; i++)
-                items.push(mockRunType(child, childOpts, stack));
-            return items;
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.tuple: {
-            const children = (runType.children ?? []);
-            const perElemOptions = mOps.tupleOptions ?? mOps.paramsOptions;
-            const itemsNode = asDataNode(dataNode?.rt$items);
-            const baseOpts = withDataNode(options, itemsNode);
-            const params = children.map((member, index) => {
-                const childOpts = perElemOptions?.[index] ? mergeChildOptions(baseOpts, perElemOptions[index]) : baseOpts;
-                return mockRunType(member, childOpts, stack);
-            });
-            const lastMember = children[children.length - 1];
-            const flattened = lastMember && isRestTupleMember(lastMember) && Array.isArray(params[params.length - 1])
-                ? [...params.slice(0, -1), ...params[params.length - 1]]
-                : params;
-            const annotation = runType.formatAnnotation;
-            let shaped = flattened;
-            if (annotation?.name === 'formattedArray') {
-                const arrayParams = (annotation.params ?? {});
-                if (arrayParams.uniqueItems === true) {
-                    const seen = new Set();
-                    shaped = shaped.filter((item) => {
-                        const key = (0, structuralFormat_ts_1.canonicalJson)(item);
-                        if (seen.has(key))
-                            return false;
-                        seen.add(key);
-                        return true;
-                    });
-                }
-                if (typeof arrayParams.maxItems === 'number' && shaped.length > arrayParams.maxItems) {
-                    shaped = shaped.slice(0, arrayParams.maxItems);
-                }
-            }
-            const tupleContains = (runType.contains ?? []);
-            for (const entry of tupleContains) {
-                const overCount = shaped.filter((item) => (0, childMatch_ts_1.childSchemaMatches)(item, entry.child)).length;
-                if (entry.min > 0 || (entry.max >= 0 && overCount > entry.max)) {
-                    throw new Error('Cannot mock contains over a tuple (prefixItems) base. Provide a MockData pool for this type (enrich).');
-                }
-            }
-            return shaped;
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.tupleMember:
-        case runTypeKind_generated_ts_1.RunTypeKind.parameter: {
-            const child = runType.child;
-            if (!child)
-                return undefined;
-            if (Array.isArray(runType.flags) && runType.flags.includes('rest') && child.kind !== runTypeKind_generated_ts_1.RunTypeKind.rest) {
-                const length = random.int(0, mOps.maxRandomItemsLength);
-                const itemOpts = shrinkForNestedItems(options, stack);
-                const items = [];
-                for (let i = 0; i < length; i++)
-                    items.push(mockRunType(child, itemOpts, stack));
-                return items;
-            }
-            if (runType.optional && !isRestTupleMember(runType)) {
-                if (random.float() > mOps.optionalProbability)
-                    return undefined;
-            }
-            return mockRunType(child, options, stack);
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.rest: {
-            const child = runType.child;
-            if (!child)
-                return [];
-            const length = random.int(0, mOps.maxRandomItemsLength);
-            const itemOpts = shrinkForNestedItems(options, stack);
-            const items = [];
-            for (let i = 0; i < length; i++)
-                items.push(mockRunType(child, itemOpts, stack));
-            return items;
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.objectLiteral:
-        case runTypeKind_generated_ts_1.RunTypeKind.intersection:
-            return buildObjectLiteral(runType, options, stack, mOps);
-        case runTypeKind_generated_ts_1.RunTypeKind.property:
-        case runTypeKind_generated_ts_1.RunTypeKind.propertySignature: {
-            const child = runType.child;
-            if (!child)
-                return undefined;
-            const name = runType.name;
-            const perPropProb = mOps.optionalPropertyProbability;
-            const probability = perPropProb && name !== undefined && perPropProb[name] !== undefined ? perPropProb[name] : mOps.optionalProbability;
-            if (probability < 0 || probability > 1) {
-                throw new Error('optionalProbability must be between 0 and 1');
-            }
-            if (runType.optional && random.float() > probability)
-                return undefined;
-            return mockRunType(child, options, stack);
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.indexSignature: {
-            const child = runType.child;
-            const keyType = runType.index;
-            if (!child || !keyType)
-                return {};
-            const length = random.int(0, mOps.maxRandomItemsLength);
-            const valueOpts = shrinkForNestedItems(options, stack);
-            const parent = mOps.parentObj ?? {};
-            const keyKind = keyType.kind;
-            for (let i = 0; i < length; i++) {
-                let propName;
-                switch (keyKind) {
-                    case runTypeKind_generated_ts_1.RunTypeKind.number:
-                        propName = i;
-                        break;
-                    case runTypeKind_generated_ts_1.RunTypeKind.string:
-                        propName = `key${i}`;
-                        break;
-                    case runTypeKind_generated_ts_1.RunTypeKind.symbol:
-                        propName = Symbol.for(`key${i}`);
-                        break;
-                    case runTypeKind_generated_ts_1.RunTypeKind.templateLiteral: {
-                        const buildKey = () => buildTemplateLiteralString(keyType, mOps, random);
-                        let candidate = buildKey();
-                        for (let attempt = 0; attempt < 5 && Object.prototype.hasOwnProperty.call(parent, candidate); attempt++) {
-                            candidate = buildKey();
-                        }
-                        propName = candidate;
-                        break;
-                    }
-                    default:
-                        throw new Error(`Invalid index signature key kind: ${keyKind}`);
-                }
-                parent[propName] = mockRunType(child, valueOpts, stack);
-            }
-            return parent;
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.union: {
-            const allChildren = (runType.children ?? []);
-            const survivors = allChildren.filter((member) => !member.notSupported);
-            const children = survivors.length > 0 ? survivors : allChildren;
-            if (children.length === 0)
-                throw new Error('Cannot mock union with no branches.');
-            if (mOps.unionIndex !== undefined && (mOps.unionIndex < 0 || mOps.unionIndex >= children.length)) {
-                throw new Error('unionIndex must be between 0 and the number of types in the union.');
-            }
-            const index = mOps.unionIndex ?? random.int(0, children.length - 1);
-            if (mOps.unionIndex !== undefined)
-                return mockRunType(children[index], options, stack);
-            let samplingFailure;
-            for (let offset = 0; offset < children.length; offset++) {
-                const arm = children[(index + offset) % children.length];
-                try {
-                    return mockRunType(arm, options, stack);
-                }
-                catch (error) {
-                    if (!(0, childMatch_ts_1.isMockSamplingError)(error))
-                        throw error;
-                    samplingFailure = error;
-                }
-            }
-            throw samplingFailure;
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.templateLiteral:
-            return buildTemplateLiteralString(runType, mOps, random);
-        case runTypeKind_generated_ts_1.RunTypeKind.promise: {
-            const child = runType.child;
-            const timeOut = mOps.promiseTimeOut || 0;
-            const resolveInner = () => (child ? mockRunType(child, options, stack) : undefined);
-            return new Promise((resolve, reject) => {
-                const finish = () => {
-                    if (mOps.promiseReject)
-                        reject(mOps.promiseReject);
-                    else
-                        resolve(resolveInner());
-                };
-                if (timeOut > 0)
-                    setTimeout(finish, timeOut);
-                else
-                    finish();
-            });
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.function:
-        case runTypeKind_generated_ts_1.RunTypeKind.callSignature:
-        case runTypeKind_generated_ts_1.RunTypeKind.method:
-        case runTypeKind_generated_ts_1.RunTypeKind.methodSignature:
-            return mOps.nonDataTypes ? mockNonDataFunction() : undefined;
-        default:
-            throw new Error(`Cannot mock runType: kind ${kind} is not yet supported by the mock walker.`);
-    }
-}
-function buildObjectLiteral(runType, options, stack, mOps) {
-    const children = (runType.children ?? []);
-    const parent = mOps.parentObj ?? {};
-    const dataNode = options.dataNode;
-    for (const member of children) {
-        const memberKind = member.kind;
-        if (memberKind === runTypeKind_generated_ts_1.RunTypeKind.method || memberKind === runTypeKind_generated_ts_1.RunTypeKind.methodSignature) {
-            const methodName = member.name;
-            if (mOps.nonDataTypes && methodName !== undefined)
-                parent[methodName] = mockNonDataFunction();
-            continue;
-        }
-        if (memberKind === runTypeKind_generated_ts_1.RunTypeKind.indexSignature) {
-            const indexed = mockRunType(member, options, stack);
-            if (indexed && typeof indexed === 'object')
-                Object.assign(parent, indexed);
-            continue;
-        }
-        const name = member.name;
-        if (name === undefined)
-            continue;
-        const memberOpts = withDataNode(options, childDataNodeByName(dataNode, name));
-        const value = mockRunType(member, memberOpts, stack);
-        parent[name] = value;
-    }
-    const annotation = runType.formatAnnotation;
-    if (annotation?.name === 'formattedObject') {
-        const params = (annotation.params ?? {});
-        const declared = new Set();
-        let indexMember;
-        for (const member of children) {
-            if (member.kind === runTypeKind_generated_ts_1.RunTypeKind.indexSignature)
-                indexMember = member;
-            const name = member.name;
-            if (name !== undefined)
-                declared.add(name);
-        }
-        const stringList = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
-        const closed = Array.isArray(params.closed) ? params.closed : undefined;
-        const closedPatterns = stringList(params.closedPatterns).map((source) => new RegExp(source));
-        const trimDisallowedKeys = () => {
-            if (!closed)
-                return;
-            for (const key of Object.keys(parent)) {
-                if (declared.has(key) || closed.includes(key))
-                    continue;
-                if (closedPatterns.some((regexp) => regexp.test(key)))
-                    continue;
-                delete parent[key];
-            }
-        };
-        trimDisallowedKeys();
-        if (typeof params.maxProperties === 'number') {
-            for (const key of Object.keys(parent)) {
-                if (Object.keys(parent).length <= params.maxProperties)
-                    break;
-                if (!declared.has(key))
-                    delete parent[key];
-            }
-        }
-        if (typeof params.minProperties === 'number' && indexMember) {
-            let attempts = 0;
-            while (Object.keys(parent).length < params.minProperties && attempts < 32) {
-                attempts++;
-                const indexed = mockRunType(indexMember, options, stack);
-                if (indexed && typeof indexed === 'object')
-                    Object.assign(parent, indexed);
-                trimDisallowedKeys();
-            }
-            if (typeof params.maxProperties === 'number') {
-                for (const key of Object.keys(parent)) {
-                    if (Object.keys(parent).length <= params.maxProperties)
-                        break;
-                    if (!declared.has(key))
-                        delete parent[key];
-                }
-            }
-        }
-    }
-    const patternProps = (runType.patternProps ?? []);
-    if (patternProps.length > 0) {
-        const regexes = patternProps.map((entry) => new RegExp(entry.source));
-        const valueOpts = shrinkForNestedItems(options, stack);
-        for (const key of Object.keys(parent)) {
-            const matching = patternProps.filter((_entry, index) => regexes[index].test(key));
-            if (matching.length === 1)
-                parent[key] = mockRunType(matching[0].value, valueOpts, stack);
-            else if (matching.length > 1)
-                delete parent[key];
-        }
-        patternProps.forEach((entry, index) => {
-            if (!entry.key)
-                return;
-            const generated = mockRunType(entry.key, options, stack);
-            if (typeof generated === 'string' && regexes[index].test(generated) && !(generated in parent)) {
-                const others = patternProps.some((_other, otherIndex) => otherIndex !== index && regexes[otherIndex].test(generated));
-                if (!others)
-                    parent[generated] = mockRunType(entry.value, valueOpts, stack);
-            }
-        });
-    }
-    const propNames = runType.propNames;
-    if (propNames && propNames.length > 0) {
-        const declaredNames = new Set();
-        for (const member of children) {
-            const name = member.name;
-            if (name !== undefined)
-                declaredNames.add(name);
-        }
-        for (const key of Object.keys(parent)) {
-            if (declaredNames.has(key))
-                continue;
-            const entryValue = parent[key];
-            delete parent[key];
-            for (let attempt = 0; attempt < 8; attempt++) {
-                const renamed = mockRunType(propNames[0], options, stack);
-                if (typeof renamed !== 'string' || renamed in parent)
-                    continue;
-                if (!propNames.every((entry) => (0, childMatch_ts_1.childSchemaMatches)(renamed, entry)))
-                    continue;
-                parent[renamed] = entryValue;
-                break;
-            }
-        }
-    }
-    return parent;
-}
-function mockNonDataFunction() {
-    return () => undefined;
-}
-function mockNonSerializableNative(runType) {
-    const className = typeof runType.typeName === 'string' ? runType.typeName : typeof runType.name === 'string' ? runType.name : '';
-    switch (className) {
-        case 'ArrayBuffer':
-            return new ArrayBuffer(8);
-        case 'SharedArrayBuffer':
-            return typeof SharedArrayBuffer !== 'undefined' ? new SharedArrayBuffer(8) : new ArrayBuffer(8);
-        case 'DataView':
-            return new DataView(new ArrayBuffer(8));
-        case 'Int8Array':
-            return new Int8Array([1, 2, 3]);
-        case 'Int32Array':
-            return new Int32Array([1, 2, 3]);
-        case 'Float64Array':
-            return new Float64Array([1.5, 2.5]);
-        default:
-            return new Uint8Array([1, 2, 3]);
-    }
-}
-function isRestTupleMember(member) {
-    if (member.kind === runTypeKind_generated_ts_1.RunTypeKind.rest)
-        return true;
-    if (Array.isArray(member.flags) && member.flags.includes('rest'))
-        return true;
-    const child = member.child;
-    return child !== undefined && child.kind === runTypeKind_generated_ts_1.RunTypeKind.rest;
-}
-function mergeChildOptions(options, childMock) {
-    const parentMock = options.mock;
-    return { ...options, mock: { ...childMock, random: childMock.random ?? parentMock.random } };
-}
-function clampToItemBounds(params, length) {
-    if (!params)
-        return length;
-    if (typeof params.maxItems === 'number' && length > params.maxItems)
-        length = params.maxItems;
-    if (typeof params.minItems === 'number' && length < params.minItems)
-        length = params.minItems;
-    return length;
-}
-function structuralParamsOf(runType, name) {
-    const annotation = runType.formatAnnotation;
-    return annotation?.name === name ? (annotation.params ?? {}) : undefined;
-}
-const COLLECTION_DRAW_ATTEMPTS = 32;
-function drawCollectionEntries(spec) {
-    const entries = [];
-    const takenKeys = new Set();
-    const seenValues = new Set();
-    const keep = (entry) => {
-        const insertKey = spec.insertKeyOf(entry);
-        if (takenKeys.has(insertKey))
-            return false;
-        if (spec.unique) {
-            const valueKey = (0, structuralFormat_ts_1.canonicalJson)(entry);
-            if (seenValues.has(valueKey))
-                return false;
-            seenValues.add(valueKey);
-        }
-        takenKeys.add(insertKey);
-        entries.push(entry);
-        return true;
-    };
-    for (const check of spec.containsChecks) {
-        if (check.max >= 0 && check.min > check.max) {
-            throw new Error('Cannot mock contains: minContains exceeds maxContains — the schema is provably empty.');
-        }
-        for (let n = 0; n < check.min; n++) {
-            let placed = false;
-            for (let attempt = 0; attempt < COLLECTION_DRAW_ATTEMPTS && !placed; attempt++)
-                placed = keep(spec.drawMatch(check.child));
-            if (!placed)
-                throw new Error(spec.collapseError);
-        }
-    }
-    let attempts = 0;
-    while (entries.length < spec.length && attempts < Math.max(spec.length, 1) * COLLECTION_DRAW_ATTEMPTS) {
-        attempts++;
-        const filler = spec.drawFiller();
-        if (spec.containsChecks.some((check) => (0, childMatch_ts_1.childSchemaMatches)(filler, check.child)))
-            continue;
-        keep(filler);
-    }
-    return entries;
-}
-function mockMap(runType, options, stack) {
-    const mOps = options.mock;
-    const random = mOps.random ?? mockRandom_ts_1.nativeMockRandom;
-    const args = (runType.arguments ?? []);
-    const keyType = args[0]?.child;
-    const valueType = args[1]?.child;
-    const result = new Map();
-    if (!keyType || !valueType)
-        return result;
-    const mapParams = structuralParamsOf(runType, 'formattedMap');
-    const entryOpts = shrinkForNestedItems(options, stack);
-    const entries = drawCollectionEntries({
-        length: clampToItemBounds(mapParams, mOps.arrayLength ?? random.int(0, mOps.maxRandomItemsLength)),
-        containsChecks: (runType.contains ?? []),
-        unique: mapParams?.uniqueItems === true,
-        drawMatch: (child) => {
-            const drawn = mockRunType(child, entryOpts, stack);
-            const pair = Array.isArray(drawn) && drawn.length === 2 ? [drawn[0], drawn[1]] : [undefined, undefined];
-            if (!(0, childMatch_ts_1.childSchemaMatches)(pair[0], keyType))
-                pair[0] = mockRunType(keyType, entryOpts, stack);
-            if (!(0, childMatch_ts_1.childSchemaMatches)(pair[1], valueType))
-                pair[1] = mockRunType(valueType, entryOpts, stack);
-            if (!(0, childMatch_ts_1.childSchemaMatches)(pair, child)) {
-                throw new Error('Cannot mock contains: the contains child and the Map entry type are contradictory (a Map entry is its ' +
-                    '[key, value] pair). Provide a MockData pool for this type (enrich).');
-            }
-            return pair;
-        },
-        drawFiller: () => [mockRunType(keyType, entryOpts, stack), mockRunType(valueType, entryOpts, stack)],
-        insertKeyOf: (pair) => pair[0],
-        collapseError: 'Cannot mock contains: a Map holds one entry per key, so the drawn matches collapsed and minContains cannot ' +
-            'be reached. Provide a MockData pool for this type (enrich).',
-    });
-    for (const [key, value] of entries)
-        result.set(key, value);
-    return result;
-}
-function mockSet(runType, options, stack) {
-    const mOps = options.mock;
-    const random = mOps.random ?? mockRandom_ts_1.nativeMockRandom;
-    const args = (runType.arguments ?? []);
-    const elementType = args[0]?.child;
-    if (!elementType)
-        return new Set();
-    const setParams = structuralParamsOf(runType, 'formattedSet');
-    const memberOpts = shrinkForNestedItems(options, stack);
-    const members = drawCollectionEntries({
-        length: clampToItemBounds(setParams, mOps.arrayLength ?? random.int(0, mOps.maxRandomItemsLength)),
-        containsChecks: (runType.contains ?? []),
-        unique: setParams?.uniqueItems === true,
-        drawMatch: (child) => {
-            const item = mockRunType(child, memberOpts, stack);
-            if (!(0, childMatch_ts_1.childSchemaMatches)(item, elementType)) {
-                throw new Error('Cannot mock contains: the contains child and the Set member type are contradictory. ' +
-                    'Provide a MockData pool for this type (enrich).');
-            }
-            return item;
-        },
-        drawFiller: () => mockRunType(elementType, memberOpts, stack),
-        insertKeyOf: (member) => member,
-        collapseError: 'Cannot mock contains: a Set holds one copy of a member, so the drawn matches collapsed and minContains ' +
-            'cannot be reached. Provide a MockData pool for this type (enrich).',
-    });
-    return new Set(members);
-}
-function buildTemplateLiteralString(runType, mOps, random) {
-    const envelope = (runType.literal ?? null);
-    const layout = envelope?.templateLiteral;
-    if (!layout || !Array.isArray(layout.texts))
-        return '';
-    const texts = layout.texts;
-    const placeholders = Array.isArray(layout.placeholders) ? layout.placeholders : [];
-    let out = '';
-    for (let i = 0; i < texts.length; i++) {
-        out += texts[i];
-        if (i < placeholders.length) {
-            out += renderTemplateLiteralPlaceholder(placeholders[i], mOps, random);
-        }
-    }
-    return out;
-}
-function renderTemplateLiteralPlaceholder(span, mOps, random) {
-    if (!span)
-        return '';
-    const kind = typeof span.kind === 'number' ? span.kind : -1;
-    switch (kind) {
-        case runTypeKind_generated_ts_1.RunTypeKind.literal:
-            return span.literal === undefined ? '' : String(span.literal);
-        case runTypeKind_generated_ts_1.RunTypeKind.number:
-            return String(random.number(mOps.minNumber, mOps.maxNumber));
-        case runTypeKind_generated_ts_1.RunTypeKind.bigint:
-            return String(random.bigint(mOps.minNumber, mOps.maxNumber));
-        case runTypeKind_generated_ts_1.RunTypeKind.string:
-        case runTypeKind_generated_ts_1.RunTypeKind.any:
-        case runTypeKind_generated_ts_1.RunTypeKind.unknown:
-            return random.string(mOps.stringLength ?? random.int(1, mOps.maxRandomStringLength), mOps.stringCharSet || constants_mock_ts_1.stringCharSet);
-        default:
-            return '';
-    }
-}