@mionjs/run-types 0.13.0 → 0.14.0

package/dist/cjs/mocking/childMatch.js

@@ -1,357 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.childSchemaMatches = childSchemaMatches;
-exports.isMockSamplingError = isMockSamplingError;
-const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
-const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
-const structuralFormat_ts_1 = require("./structuralFormat.js");
-const isMultipleOf_ts_1 = require("./isMultipleOf.js");
-const MAX_MATCH_DEPTH = 16;
-function childSchemaMatches(value, child) {
-    return matches(value, child, 0);
-}
-function matches(value, node, depth) {
-    if (depth > MAX_MATCH_DEPTH)
-        throw childMatchError('recursion exceeded MAX_MATCH_DEPTH');
-    const kind = node.kind;
-    switch (kind) {
-        case runTypeKind_generated_ts_1.RunTypeKind.ref: {
-            const resolved = (0, rtUtils_ts_1.getRTUtils)().getRunType(node.id);
-            if (!resolved)
-                throw childMatchError(`unresolvable ref '${String(node.id)}'`);
-            return matches(value, resolved, depth + 1);
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.any:
-        case runTypeKind_generated_ts_1.RunTypeKind.unknown:
-            return true;
-        case runTypeKind_generated_ts_1.RunTypeKind.never:
-            return false;
-        case runTypeKind_generated_ts_1.RunTypeKind.null:
-            return value === null;
-        case runTypeKind_generated_ts_1.RunTypeKind.undefined:
-        case runTypeKind_generated_ts_1.RunTypeKind.void:
-            return value === undefined;
-        case runTypeKind_generated_ts_1.RunTypeKind.boolean:
-            return typeof value === 'boolean';
-        case runTypeKind_generated_ts_1.RunTypeKind.string:
-            return typeof value === 'string' && formatMatches(value, node.formatAnnotation);
-        case runTypeKind_generated_ts_1.RunTypeKind.number:
-            return Number.isFinite(value) && numberParamsMatch(value, node.formatAnnotation);
-        case runTypeKind_generated_ts_1.RunTypeKind.bigint:
-            return typeof value === 'bigint' && bigintParamsMatch(value, node.formatAnnotation);
-        case runTypeKind_generated_ts_1.RunTypeKind.literal:
-            return literalMatches(value, node);
-        case runTypeKind_generated_ts_1.RunTypeKind.enum: {
-            const values = Array.isArray(node.values) ? node.values : [];
-            return values.some((entry) => entry === value);
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.object:
-            return (typeof value === 'object' &&
-                value !== null &&
-                (0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation) &&
-                patternKeysSatisfied(value, node, depth));
-        case runTypeKind_generated_ts_1.RunTypeKind.array:
-            if (!Array.isArray(value) || !(0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation))
-                return false;
-            if (!containsSatisfied(value, node, depth))
-                return false;
-            return node.child ? value.every((item) => matches(item, node.child, depth + 1)) : true;
-        case runTypeKind_generated_ts_1.RunTypeKind.tuple: {
-            if (!Array.isArray(value))
-                return false;
-            if (!(0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation))
-                return false;
-            if (!containsSatisfied(value, node, depth))
-                return false;
-            const members = node.children ?? [];
-            const lastMember = members[members.length - 1];
-            const restMember = lastMember !== undefined && restElement(lastMember) !== undefined ? lastMember : undefined;
-            const fixed = restMember === undefined ? members : members.slice(0, -1);
-            const required = fixed.filter((member) => !member.optional).length;
-            if (value.length < required)
-                return false;
-            if (restMember === undefined && value.length > fixed.length)
-                return false;
-            return value.every((item, i) => {
-                if (i < fixed.length)
-                    return fixed[i] ? matches(item, memberChild(fixed[i]), depth + 1) : false;
-                const element = restElement(restMember);
-                return element === undefined ? true : matches(item, element, depth + 1);
-            });
-        }
-        case runTypeKind_generated_ts_1.RunTypeKind.union:
-            return (node.children ?? []).some((arm) => matches(value, arm, depth + 1));
-        case runTypeKind_generated_ts_1.RunTypeKind.objectLiteral: {
-            if (typeof value !== 'object' || value === null || Array.isArray(value))
-                return false;
-            if (!(0, structuralFormat_ts_1.structuralFormatAccepts)(value, node.formatAnnotation))
-                return false;
-            if (!patternKeysSatisfied(value, node, depth))
-                return false;
-            const record = value;
-            for (const member of node.children ?? []) {
-                if (member.kind === runTypeKind_generated_ts_1.RunTypeKind.indexSignature) {
-                    const valueChild = member.child;
-                    if (valueChild && !Object.values(record).every((entry) => matches(entry, valueChild, depth + 1)))
-                        return false;
-                    continue;
-                }
-                const name = member.name;
-                if (name === undefined)
-                    continue;
-                if (!(name in record)) {
-                    if (member.optional)
-                        continue;
-                    return false;
-                }
-                if (!matches(record[name], memberChild(member), depth + 1))
-                    return false;
-            }
-            return true;
-        }
-        default:
-            throw childMatchError(`cannot test a candidate against child kind ${kind}`);
-    }
-}
-function memberChild(member) {
-    return member.child ?? member;
-}
-function containsSatisfied(items, node, depth) {
-    const entries = node.contains;
-    if (!entries || entries.length === 0)
-        return true;
-    for (const entry of entries) {
-        let count = 0;
-        for (const item of items)
-            if (matches(item, entry.child, depth + 1))
-                count++;
-        if (count < entry.min)
-            return false;
-        if (entry.max >= 0 && count > entry.max)
-            return false;
-    }
-    return true;
-}
-function patternKeysSatisfied(record, node, depth) {
-    const patternProps = node.patternProps;
-    if (patternProps && patternProps.length > 0) {
-        for (const entry of patternProps) {
-            for (const [key, entryValue] of Object.entries(record)) {
-                if (new RegExp(entry.source).test(key) && !matches(entryValue, entry.value, depth + 1))
-                    return false;
-            }
-        }
-    }
-    const propNames = node.propNames;
-    if (propNames && propNames.length > 0) {
-        for (const entry of propNames) {
-            for (const key of Object.keys(record)) {
-                if (!matches(key, entry, depth + 1))
-                    return false;
-            }
-        }
-    }
-    return true;
-}
-function restElement(member) {
-    if (member.kind === runTypeKind_generated_ts_1.RunTypeKind.rest)
-        return member.child;
-    if (Array.isArray(member.flags) && member.flags.includes('rest'))
-        return member.child;
-    const child = member.child;
-    if (child && child.kind === runTypeKind_generated_ts_1.RunTypeKind.rest)
-        return child.child;
-    return undefined;
-}
-function literalMatches(value, node) {
-    const literal = node.literal;
-    if (Array.isArray(node.flags) && node.flags.includes('bigint')) {
-        return typeof value === 'bigint' && value.toString() === String(literal);
-    }
-    return value === literal;
-}
-function patternTest(param, value) {
-    const pattern = param;
-    if (!pattern || typeof pattern.source !== 'string') {
-        throw childMatchError('pattern param without a literal source');
-    }
-    return new RegExp(pattern.source, typeof pattern.flags === 'string' ? pattern.flags : '').test(value);
-}
-const NAMED_STRING_FORMATS = {
-    email: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
-    uuid: (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value),
-    date: (value) => /^\d{4}-\d{2}-\d{2}$/.test(value),
-    time: (value) => /^\d{2}:\d{2}(:\d{2})?/.test(value),
-    dateTime: (value) => /^\d{4}-\d{2}-\d{2}[Tt ]/.test(value),
-    ip: (value) => /^(\d{1,3}\.){3}\d{1,3}$/.test(value) || value.includes(':'),
-    domain: (value) => /^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(value),
-    url: (value) => {
-        try {
-            new URL(value);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    },
-};
-function formatMatches(value, annotation) {
-    if (!annotation)
-        return true;
-    const name = annotation.name;
-    const params = annotation.params ?? {};
-    if (name === 'stringFormat')
-        return stringParamsMatch(value, params);
-    if (params.pattern)
-        return stringParamsMatch(value, params);
-    const named = NAMED_STRING_FORMATS[name];
-    if (!named)
-        throw childMatchError(`no runtime test for string format '${name}'`);
-    return named(value);
-}
-function stringParamsMatch(value, params) {
-    for (const [key, param] of Object.entries(params)) {
-        switch (key) {
-            case 'contentMediaType': {
-                if (param !== 'application/json')
-                    break;
-                try {
-                    JSON.parse(params.contentEncoding === 'base64' ? atob(value) : value);
-                }
-                catch {
-                    return false;
-                }
-                break;
-            }
-            case 'contentEncoding':
-                break;
-            case 'minLength':
-                if (typeof param === 'number' && value.length < param)
-                    return false;
-                break;
-            case 'maxLength':
-                if (typeof param === 'number' && value.length > param)
-                    return false;
-                break;
-            case 'length':
-                if (typeof param === 'number' && value.length !== param)
-                    return false;
-                break;
-            case 'pattern':
-                if (!patternTest(param, value))
-                    return false;
-                break;
-            case 'allowedChars':
-                if (!patternTest(param, value))
-                    return false;
-                break;
-            case 'disallowedChars':
-                if (patternTest(param, value))
-                    return false;
-                break;
-            case 'allowedValues':
-                if (Array.isArray(param) && !param.includes(value))
-                    return false;
-                break;
-            case 'disallowedValues':
-                if (Array.isArray(param) && param.includes(value))
-                    return false;
-                break;
-            case 'idna':
-                if (param !== 'ascii')
-                    throw childMatchError(`no runtime test for idna '${String(param)}'`);
-                break;
-            case 'mockSamples':
-                break;
-            default:
-                throw childMatchError(`no runtime test for string param '${key}'`);
-        }
-    }
-    return true;
-}
-function numberParamsMatch(value, annotation) {
-    if (!annotation)
-        return true;
-    const params = annotation.params ?? {};
-    for (const [key, param] of Object.entries(params)) {
-        switch (key) {
-            case 'min':
-                if (typeof param === 'number' && value < param)
-                    return false;
-                break;
-            case 'max':
-                if (typeof param === 'number' && value > param)
-                    return false;
-                break;
-            case 'gt':
-                if (typeof param === 'number' && value <= param)
-                    return false;
-                break;
-            case 'lt':
-                if (typeof param === 'number' && value >= param)
-                    return false;
-                break;
-            case 'integer':
-                if (param === true && !Number.isInteger(value))
-                    return false;
-                break;
-            case 'multipleOf': {
-                const tolerance = params.multipleOfTolerance;
-                if (typeof param === 'number' &&
-                    param !== 0 &&
-                    !(0, isMultipleOf_ts_1.isMultipleOf)(value, param, typeof tolerance === 'number' ? tolerance : undefined))
-                    return false;
-                break;
-            }
-            case 'multipleOfTolerance':
-            case 'isCurrency':
-            case 'mockSamples':
-                break;
-            default:
-                throw childMatchError(`no runtime test for number param '${key}'`);
-        }
-    }
-    return true;
-}
-function bigintParamsMatch(value, annotation) {
-    if (!annotation)
-        return true;
-    const params = annotation.params ?? {};
-    for (const [key, param] of Object.entries(params)) {
-        switch (key) {
-            case 'min':
-                if (value < BigInt(param))
-                    return false;
-                break;
-            case 'max':
-                if (value > BigInt(param))
-                    return false;
-                break;
-            case 'gt':
-                if (value <= BigInt(param))
-                    return false;
-                break;
-            case 'lt':
-                if (value >= BigInt(param))
-                    return false;
-                break;
-            case 'multipleOf': {
-                const divisor = BigInt(param);
-                if (divisor !== 0n && value % divisor !== 0n)
-                    return false;
-                break;
-            }
-            case 'mockSamples':
-                break;
-            default:
-                throw childMatchError(`no runtime test for bigint param '${key}'`);
-        }
-    }
-    return true;
-}
-function childMatchError(reason) {
-    return new Error(`Cannot mock a constrained child (${reason}). Provide a MockData pool for this type (enrich) with values that satisfy the constraint.`);
-}
-function isMockSamplingError(error) {
-    return error instanceof Error && error.message.startsWith('Cannot mock a constrained child');
-}

package/dist/cjs/mocking/constants.mock.d.ts

@@ -1,7 +0,0 @@
-import type { MockOptions } from './mockTypes.ts';
-export declare const mockRegExpsList: RegExp[];
-export declare const stringCharSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,";
-export declare const emailLocalPartSymbols = "._%-";
-export declare const anyValuesList: unknown[];
-export declare const mockObjectList: object[];
-export declare const defaultMockOptions: MockOptions;

package/dist/cjs/mocking/constants.mock.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMockOptions = exports.mockObjectList = exports.anyValuesList = exports.emailLocalPartSymbols = exports.stringCharSet = exports.mockRegExpsList = void 0;
-exports.mockRegExpsList = [
-    /abc/,
-    /def/,
-    /123/,
-    /xyz/,
-    /[\w]+/,
-    /\d{3}-\d{3}-\d{4}/,
-    /[A-Z]/,
-    /[a-z]/,
-    /\d+/,
-    /\s+/,
-    /^https:\/\/[\w.-]+\.[a-zA-Z]{2,}$/i,
-    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i,
-    /\b\d{2}\/\d{2}\/\d{4}\b/,
-    /\b\d{1,2}:\d{2}\b/,
-    /\b\d{1,2}:\d{2}:\d{2}\b/,
-    /\b\d{1,2}\/\d{1,2}\/\d{2}\b/,
-    /\b\d{1,2}\/\d{1,2}\/\d{4}\b/,
-    /\b\d{1,2}:\d{2}:\d{2} [AP]M\b/,
-    /\b\d{1,2}:\d{2} [AP]M\b/,
-    /abc/gi,
-    /['"]/,
-    /\/(.*)\/(.*)?/,
-    /\/\//,
-    /`/,
-    /\/\\\//,
-];
-exports.stringCharSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 .>?<~!@#$%^&*()_+-=[]{}|;:,';
-exports.emailLocalPartSymbols = '._%-';
-exports.anyValuesList = [
-    {},
-    { hello: 'world' },
-    [],
-    [1, 3, 'hello'],
-    'hello',
-    1234,
-    BigInt(1),
-    true,
-    false,
-    null,
-    undefined,
-    Symbol('hello'),
-    -124,
-    0,
-    124,
-    0.1,
-    -0.1,
-    Infinity,
-    NaN,
-    new Date(),
-    /abc/,
-    new Map([
-        ['zero', 0],
-        ['one', 1],
-        ['two', 2],
-        ['three', 3],
-        ['four', 4],
-    ]),
-    new Set(['zero', 1, 2, 3, 'four']),
-];
-exports.mockObjectList = [
-    {},
-    { a: 1 },
-    { b: 2 },
-    { a: 1, b: 'hello' },
-    { a: 1, b: 2, c: 3 },
-    { a: 'hello', b: 2, c: 'wold', d: 4 },
-];
-exports.defaultMockOptions = {
-    anyValuesList: exports.anyValuesList,
-    promiseTimeOut: 1,
-    regexpList: exports.mockRegExpsList,
-    maxRandomStringLength: 100,
-    stringCharSet: exports.stringCharSet,
-    maxRandomItemsLength: 60,
-    optionalProbability: 0.5,
-    objectList: exports.mockObjectList,
-    maxStackDepth: 50,
-    maxMockRecursion: 10,
-    nonDataTypes: false,
-    invalid: false,
-    invalidLeafProbability: 0.85,
-    seed: undefined,
-};

package/dist/cjs/mocking/createMockData.d.ts

@@ -1,8 +0,0 @@
-import './mockStringFormat.ts';
-import './mockNumberFormat.ts';
-import './mockBigIntFormat.ts';
-import type { RunType } from '../runtypes/types.ts';
-import type { CompTimeHints, InjectRunTypeId } from '../index.ts';
-import type { MockTypeFn, RunTypeMockOptions } from './mockTypes.ts';
-export declare function createMockDataFn<T>(runType: RunType<T>, options?: CompTimeHints<RunTypeMockOptions<T>>, id?: InjectRunTypeId<T>): MockTypeFn<T>;
-export declare function createMockDataFn<T>(val?: T, options?: CompTimeHints<RunTypeMockOptions<T>>, id?: InjectRunTypeId<T>): MockTypeFn<T>;

package/dist/cjs/mocking/createMockData.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMockDataFn = createMockDataFn;
-const rtUtils_ts_1 = require("../runtypes/rtUtils.js");
-const entryTuple_ts_1 = require("../runtypes/entryTuple.js");
-require("./mockStringFormat.js");
-require("./mockNumberFormat.js");
-require("./mockBigIntFormat.js");
-const mockType_ts_1 = require("./mockType.js");
-const mockInvalid_ts_1 = require("./mockInvalid.js");
-const mockRandom_ts_1 = require("./mockRandom.js");
-const constants_mock_ts_1 = require("./constants.mock.js");
-function createMockDataFn(valOrSchema, options, id) {
-    let injectedId = id;
-    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
-        (0, entryTuple_ts_1.initFromTuple)(id);
-        injectedId = (0, entryTuple_ts_1.entryTupleKey)(id);
-    }
-    const effectiveId = (0, rtUtils_ts_1.isRunTypeValue)(valOrSchema) ? valOrSchema.id : injectedId;
-    if (effectiveId === undefined) {
-        throw new Error('createMockDataFn(): no id injected. @mionjs/devtools must be active for createMockDataFn to resolve the runtype graph.');
-    }
-    const utils = (0, rtUtils_ts_1.getRTUtils)();
-    const runType = utils.getRunType(effectiveId);
-    if (!runType) {
-        throw new Error(`createMockDataFn(): no RunType entry for "${effectiveId}" in rtUtils. The build pipeline didn't emit a cache entry for that runtype.`);
-    }
-    const factoryOpts = mergeMockOptions(undefined, options);
-    return ((callOpts) => {
-        const merged = mergeMockOptions(factoryOpts, callOpts);
-        const mockOpts = merged.mock;
-        mockOpts.random = mockOpts.seed === undefined ? mockRandom_ts_1.nativeMockRandom : new mockRandom_ts_1.MockRandom(mockOpts.seed);
-        if (mockOpts.invalid)
-            return (0, mockInvalid_ts_1.mockRunTypeInvalid)(runType, merged, []);
-        return (0, mockType_ts_1.mockRunType)(runType, merged, []);
-    });
-}
-function mergeMockOptions(factoryOpts, callOpts) {
-    const factoryMock = factoryOpts?.mock;
-    const callMock = callOpts?.mock;
-    const merged = {
-        ...constants_mock_ts_1.defaultMockOptions,
-        ...factoryMock,
-        ...callMock,
-    };
-    const data = (callOpts?.data ?? factoryOpts?.data);
-    const result = { mock: merged };
-    if (data !== undefined) {
-        result.data = data;
-        result.dataNode = data;
-    }
-    return result;
-}

package/dist/cjs/mocking/index.d.ts

@@ -1,4 +0,0 @@
-export { createMockDataFn } from './createMockData.ts';
-export type { MockOptions, MockTypeFn, RunTypeMockOptions } from './mockTypes.ts';
-export { MockRandom } from './mockRandom.ts';
-export { registerMockingFunction, type MockFormatFn } from './mockRegistry.ts';

package/dist/cjs/mocking/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerMockingFunction = exports.MockRandom = exports.createMockDataFn = void 0;
-var createMockData_ts_1 = require("./createMockData.js");
-Object.defineProperty(exports, "createMockDataFn", { enumerable: true, get: function () { return createMockData_ts_1.createMockDataFn; } });
-var mockRandom_ts_1 = require("./mockRandom.js");
-Object.defineProperty(exports, "MockRandom", { enumerable: true, get: function () { return mockRandom_ts_1.MockRandom; } });
-var mockRegistry_ts_1 = require("./mockRegistry.js");
-Object.defineProperty(exports, "registerMockingFunction", { enumerable: true, get: function () { return mockRegistry_ts_1.registerMockingFunction; } });

package/dist/cjs/mocking/isMultipleOf.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_MULTIPLE_OF_TOLERANCE: number;
-export declare function isMultipleOf(value: number, step: number, tolerance?: number): boolean;

package/dist/cjs/mocking/isMultipleOf.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MULTIPLE_OF_TOLERANCE = void 0;
-exports.isMultipleOf = isMultipleOf;
-exports.DEFAULT_MULTIPLE_OF_TOLERANCE = 4 * Number.EPSILON;
-function isMultipleOf(value, step, tolerance = exports.DEFAULT_MULTIPLE_OF_TOLERANCE) {
-    if (Number.isInteger(step))
-        return value % step === 0;
-    const quotient = value / step;
-    return Math.abs(quotient - Math.round(quotient)) <= Math.abs(quotient) * tolerance;
-}

package/dist/cjs/mocking/mockBigIntFormat.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cjs/mocking/mockBigIntFormat.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
-const mockRegistry_ts_1 = require("./mockRegistry.js");
-const mockRandom_ts_1 = require("./mockRandom.js");
-const mockBigIntFormat = (annotation, random = mockRandom_ts_1.nativeMockRandom) => {
-    if (annotation.name !== 'bigintFormat')
-        return undefined;
-    return mockBigIntParams((annotation.params ?? {}), random);
-};
-(0, mockRegistry_ts_1.registerMockingFunction)(runTypeKind_generated_ts_1.RunTypeKind.bigint, mockBigIntFormat);
-const MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
-const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
-function mockBigIntParams(params, random) {
-    let min = params.min !== undefined ? toBig(params.min) : -99999n;
-    let max = params.max !== undefined ? toBig(params.max) : 99999n;
-    if (params.gt !== undefined)
-        min = toBig(params.gt) + 1n;
-    if (params.lt !== undefined)
-        max = toBig(params.lt) - 1n;
-    const minNum = Number(min > MIN_SAFE ? min : MIN_SAFE);
-    const maxNum = Number(max < MAX_SAFE ? max : MAX_SAFE);
-    let result = BigInt(random.int(minNum, maxNum));
-    if (params.multipleOf !== undefined) {
-        const multipleOf = toBig(params.multipleOf);
-        result = (result / multipleOf) * multipleOf;
-    }
-    return result;
-}
-function toBig(value) {
-    if (typeof value === 'bigint')
-        return value;
-    if (typeof value === 'number')
-        return BigInt(Math.trunc(value));
-    if (value !== null && typeof value === 'object' && 'val' in value)
-        return toBig(value.val);
-    return BigInt(String(value).replace(/n$/, ''));
-}

package/dist/cjs/mocking/mockDateTimeBounds.d.ts

@@ -1,13 +0,0 @@
-import type { DateFmt, TimeFmt, DateTimeParams } from '../formats/datetime/stringDateTimeFormats.ts';
-import type { MockRandom } from './mockRandom.ts';
-interface BoundInputs {
-    min?: string;
-    max?: string;
-    gt?: string;
-    lt?: string;
-}
-export declare function mockBoundedDate(layout: DateFmt, bounds: BoundInputs, random: MockRandom): string;
-export declare function mockBoundedTime(layout: TimeFmt, bounds: BoundInputs, random: MockRandom): string;
-export declare function mockBoundedDateTime(params: Partial<DateTimeParams>, random: MockRandom): string;
-export declare function mockBoundedNativeDate(bounds: BoundInputs, random: MockRandom): Date;
-export {};