@highstate/designer 0.1.0 → 0.2.0

package/.output/server/node_modules/zod/package.json

@@ -1,119 +0,0 @@
-{
-  "name": "zod",
-  "version": "3.23.8",
-  "author": "Colin McDonnell <colin@colinhacks.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/colinhacks/zod.git"
-  },
-  "main": "./lib/index.js",
-  "module": "./lib/index.mjs",
-  "devDependencies": {
-    "@babel/core": "^7.22.5",
-    "@babel/preset-env": "^7.22.5",
-    "@babel/preset-typescript": "^7.22.5",
-    "@jest/globals": "^29.4.3",
-    "@rollup/plugin-typescript": "^8.2.0",
-    "@swc/core": "^1.3.66",
-    "@swc/jest": "^0.2.26",
-    "@types/benchmark": "^2.1.0",
-    "@types/jest": "^29.2.2",
-    "@types/node": "14",
-    "@typescript-eslint/eslint-plugin": "^5.15.0",
-    "@typescript-eslint/parser": "^5.15.0",
-    "babel-jest": "^29.5.0",
-    "benchmark": "^2.1.4",
-    "dependency-cruiser": "^9.19.0",
-    "eslint": "^8.11.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-ban": "^1.6.0",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
-    "eslint-plugin-unused-imports": "^2.0.0",
-    "husky": "^7.0.4",
-    "jest": "^29.3.1",
-    "lint-staged": "^12.3.7",
-    "nodemon": "^2.0.15",
-    "prettier": "^2.6.0",
-    "pretty-quick": "^3.1.3",
-    "rollup": "^2.70.1",
-    "ts-jest": "^29.1.0",
-    "ts-morph": "^14.0.0",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.3.1",
-    "tsx": "^3.8.0",
-    "typescript": "~4.5.5",
-    "vitest": "^0.32.2"
-  },
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "require": "./lib/index.js",
-      "import": "./lib/index.mjs"
-    },
-    "./package.json": "./package.json",
-    "./locales/*": "./lib/locales/*"
-  },
-  "bugs": {
-    "url": "https://github.com/colinhacks/zod/issues"
-  },
-  "description": "TypeScript-first schema declaration and validation library with static type inference",
-  "files": [
-    "/lib",
-    "/index.d.ts"
-  ],
-  "funding": "https://github.com/sponsors/colinhacks",
-  "homepage": "https://zod.dev",
-  "keywords": [
-    "typescript",
-    "schema",
-    "validation",
-    "type",
-    "inference"
-  ],
-  "license": "MIT",
-  "lint-staged": {
-    "src/*.ts": [
-      "eslint --cache --fix",
-      "prettier --ignore-unknown --write"
-    ],
-    "*.md": [
-      "prettier --ignore-unknown --write"
-    ]
-  },
-  "scripts": {
-    "prettier:check": "prettier --check src/**/*.ts deno/lib/**/*.ts *.md --no-error-on-unmatched-pattern",
-    "prettier:fix": "prettier --write src/**/*.ts deno/lib/**/*.ts *.md --ignore-unknown --no-error-on-unmatched-pattern",
-    "lint:check": "eslint --cache --ext .ts ./src",
-    "lint:fix": "eslint --cache --fix --ext .ts ./src",
-    "check": "yarn lint:check && yarn prettier:check",
-    "fix": "yarn lint:fix && yarn prettier:fix",
-    "clean": "rm -rf lib/* deno/lib/*",
-    "build": "yarn run clean && npm run build:cjs && npm run build:esm && npm run build:deno",
-    "build:deno": "node ./deno-build.mjs && cp ./README.md ./deno/lib",
-    "build:esm": "rollup --config ./configs/rollup.config.js",
-    "build:cjs": "tsc -p ./configs/tsconfig.cjs.json",
-    "build:types": "tsc -p ./configs/tsconfig.types.json",
-    "build:test": "tsc -p ./configs/tsconfig.test.json",
-    "test:watch": "yarn test:ts-jest --watch",
-    "test": "yarn test:ts-jest",
-    "test:babel": "jest --coverage --config ./configs/babel-jest.config.json",
-    "test:bun": "bun test src/",
-    "test:vitest": "npx vitest --config ./configs/vitest.config.ts",
-    "test:ts-jest": "npx jest --config ./configs/ts-jest.config.json",
-    "test:swc": "npx jest --config ./configs/swc-jest.config.json",
-    "test:deno": "cd deno && deno test",
-    "prepublishOnly": "npm run test && npm run build && npm run build:deno",
-    "play": "nodemon -e ts -w . -x tsx playground.ts",
-    "depcruise": "depcruise -c .dependency-cruiser.js src",
-    "benchmark": "tsx src/benchmarks/index.ts",
-    "prepare": "husky install"
-  },
-  "sideEffects": false,
-  "support": {
-    "backing": {
-      "npm-funding": true
-    }
-  },
-  "types": "./index.d.ts"
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/Options.js

@@ -1,31 +0,0 @@
-export const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-export const defaultOptions = {
-    name: undefined,
-    $refStrategy: "root",
-    basePath: ["#"],
-    effectStrategy: "input",
-    pipeStrategy: "all",
-    dateStrategy: "format:date-time",
-    mapStrategy: "entries",
-    removeAdditionalStrategy: "passthrough",
-    definitionPath: "definitions",
-    target: "jsonSchema7",
-    strictUnions: false,
-    definitions: {},
-    errorMessages: false,
-    markdownDescription: false,
-    patternStrategy: "escape",
-    applyRegexFlags: false,
-    emailStrategy: "format:email",
-    base64Strategy: "contentEncoding:base64",
-    nameStrategy: "ref"
-};
-export const getDefaultOptions = (options) => (typeof options === "string"
-    ? {
-        ...defaultOptions,
-        name: options,
-    }
-    : {
-        ...defaultOptions,
-        ...options,
-    });

package/.output/server/node_modules/zod-to-json-schema/dist/esm/Refs.js

@@ -1,21 +0,0 @@
-import { getDefaultOptions } from "./Options.js";
-export const getRefs = (options) => {
-    const _options = getDefaultOptions(options);
-    const currentPath = _options.name !== undefined
-        ? [..._options.basePath, _options.definitionPath, _options.name]
-        : _options.basePath;
-    return {
-        ..._options,
-        currentPath: currentPath,
-        propertyPath: undefined,
-        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-            def._def,
-            {
-                def: def._def,
-                path: [..._options.basePath, _options.definitionPath, name],
-                // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-                jsonSchema: undefined,
-            },
-        ])),
-    };
-};

package/.output/server/node_modules/zod-to-json-schema/dist/esm/errorMessages.js

@@ -1,14 +0,0 @@
-export function addErrorMessage(res, key, errorMessage, refs) {
-    if (!refs?.errorMessages)
-        return;
-    if (errorMessage) {
-        res.errorMessage = {
-            ...res.errorMessage,
-            [key]: errorMessage,
-        };
-    }
-}
-export function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-    res[key] = value;
-    addErrorMessage(res, key, errorMessage, refs);
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/index.js

@@ -1,37 +0,0 @@
-export * from "./Options.js";
-export * from "./Refs.js";
-export * from "./errorMessages.js";
-export * from "./parseDef.js";
-export * from "./parsers/any.js";
-export * from "./parsers/array.js";
-export * from "./parsers/bigint.js";
-export * from "./parsers/boolean.js";
-export * from "./parsers/branded.js";
-export * from "./parsers/catch.js";
-export * from "./parsers/date.js";
-export * from "./parsers/default.js";
-export * from "./parsers/effects.js";
-export * from "./parsers/enum.js";
-export * from "./parsers/intersection.js";
-export * from "./parsers/literal.js";
-export * from "./parsers/map.js";
-export * from "./parsers/nativeEnum.js";
-export * from "./parsers/never.js";
-export * from "./parsers/null.js";
-export * from "./parsers/nullable.js";
-export * from "./parsers/number.js";
-export * from "./parsers/object.js";
-export * from "./parsers/optional.js";
-export * from "./parsers/pipeline.js";
-export * from "./parsers/promise.js";
-export * from "./parsers/readonly.js";
-export * from "./parsers/record.js";
-export * from "./parsers/set.js";
-export * from "./parsers/string.js";
-export * from "./parsers/tuple.js";
-export * from "./parsers/undefined.js";
-export * from "./parsers/union.js";
-export * from "./parsers/unknown.js";
-export * from "./zodToJsonSchema.js";
-import { zodToJsonSchema } from "./zodToJsonSchema.js";
-export default zodToJsonSchema;

package/.output/server/node_modules/zod-to-json-schema/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parseDef.js

@@ -1,164 +0,0 @@
-import { ZodFirstPartyTypeKind } from "zod";
-import { parseAnyDef } from "./parsers/any.js";
-import { parseArrayDef } from "./parsers/array.js";
-import { parseBigintDef } from "./parsers/bigint.js";
-import { parseBooleanDef } from "./parsers/boolean.js";
-import { parseBrandedDef } from "./parsers/branded.js";
-import { parseCatchDef } from "./parsers/catch.js";
-import { parseDateDef } from "./parsers/date.js";
-import { parseDefaultDef } from "./parsers/default.js";
-import { parseEffectsDef } from "./parsers/effects.js";
-import { parseEnumDef } from "./parsers/enum.js";
-import { parseIntersectionDef, } from "./parsers/intersection.js";
-import { parseLiteralDef } from "./parsers/literal.js";
-import { parseMapDef } from "./parsers/map.js";
-import { parseNativeEnumDef, } from "./parsers/nativeEnum.js";
-import { parseNeverDef } from "./parsers/never.js";
-import { parseNullDef } from "./parsers/null.js";
-import { parseNullableDef, } from "./parsers/nullable.js";
-import { parseNumberDef } from "./parsers/number.js";
-import { parseObjectDef } from "./parsers/object.js";
-import { parseOptionalDef } from "./parsers/optional.js";
-import { parsePipelineDef } from "./parsers/pipeline.js";
-import { parsePromiseDef } from "./parsers/promise.js";
-import { parseRecordDef } from "./parsers/record.js";
-import { parseSetDef } from "./parsers/set.js";
-import { parseStringDef } from "./parsers/string.js";
-import { parseTupleDef } from "./parsers/tuple.js";
-import { parseUndefinedDef, } from "./parsers/undefined.js";
-import { parseUnionDef } from "./parsers/union.js";
-import { parseUnknownDef } from "./parsers/unknown.js";
-import { parseReadonlyDef } from "./parsers/readonly.js";
-import { ignoreOverride } from "./Options.js";
-export function parseDef(def, refs, forceResolution = false) {
-    const seenItem = refs.seen.get(def);
-    if (refs.override) {
-        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-        if (overrideResult !== ignoreOverride) {
-            return overrideResult;
-        }
-    }
-    if (seenItem && !forceResolution) {
-        const seenSchema = get$ref(seenItem, refs);
-        if (seenSchema !== undefined) {
-            return seenSchema;
-        }
-    }
-    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
-    refs.seen.set(def, newItem);
-    const jsonSchema = selectParser(def, def.typeName, refs);
-    if (jsonSchema) {
-        addMeta(def, refs, jsonSchema);
-    }
-    newItem.jsonSchema = jsonSchema;
-    return jsonSchema;
-}
-const get$ref = (item, refs) => {
-    switch (refs.$refStrategy) {
-        case "root":
-            return { $ref: item.path.join("/") };
-        case "relative":
-            return { $ref: getRelativePath(refs.currentPath, item.path) };
-        case "none":
-        case "seen": {
-            if (item.path.length < refs.currentPath.length &&
-                item.path.every((value, index) => refs.currentPath[index] === value)) {
-                console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-                return {};
-            }
-            return refs.$refStrategy === "seen" ? {} : undefined;
-        }
-    }
-};
-const getRelativePath = (pathA, pathB) => {
-    let i = 0;
-    for (; i < pathA.length && i < pathB.length; i++) {
-        if (pathA[i] !== pathB[i])
-            break;
-    }
-    return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-const selectParser = (def, typeName, refs) => {
-    switch (typeName) {
-        case ZodFirstPartyTypeKind.ZodString:
-            return parseStringDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodNumber:
-            return parseNumberDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodObject:
-            return parseObjectDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBigInt:
-            return parseBigintDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBoolean:
-            return parseBooleanDef();
-        case ZodFirstPartyTypeKind.ZodDate:
-            return parseDateDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodUndefined:
-            return parseUndefinedDef();
-        case ZodFirstPartyTypeKind.ZodNull:
-            return parseNullDef(refs);
-        case ZodFirstPartyTypeKind.ZodArray:
-            return parseArrayDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodUnion:
-        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-            return parseUnionDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodIntersection:
-            return parseIntersectionDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodTuple:
-            return parseTupleDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodRecord:
-            return parseRecordDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodLiteral:
-            return parseLiteralDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodEnum:
-            return parseEnumDef(def);
-        case ZodFirstPartyTypeKind.ZodNativeEnum:
-            return parseNativeEnumDef(def);
-        case ZodFirstPartyTypeKind.ZodNullable:
-            return parseNullableDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodOptional:
-            return parseOptionalDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodMap:
-            return parseMapDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodSet:
-            return parseSetDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodLazy:
-            return parseDef(def.getter()._def, refs);
-        case ZodFirstPartyTypeKind.ZodPromise:
-            return parsePromiseDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodNaN:
-        case ZodFirstPartyTypeKind.ZodNever:
-            return parseNeverDef();
-        case ZodFirstPartyTypeKind.ZodEffects:
-            return parseEffectsDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodAny:
-            return parseAnyDef();
-        case ZodFirstPartyTypeKind.ZodUnknown:
-            return parseUnknownDef();
-        case ZodFirstPartyTypeKind.ZodDefault:
-            return parseDefaultDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBranded:
-            return parseBrandedDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodReadonly:
-            return parseReadonlyDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodCatch:
-            return parseCatchDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodPipeline:
-            return parsePipelineDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodFunction:
-        case ZodFirstPartyTypeKind.ZodVoid:
-        case ZodFirstPartyTypeKind.ZodSymbol:
-            return undefined;
-        default:
-            /* c8 ignore next */
-            return ((_) => undefined)(typeName);
-    }
-};
-const addMeta = (def, refs, jsonSchema) => {
-    if (def.description) {
-        jsonSchema.description = def.description;
-        if (refs.markdownDescription) {
-            jsonSchema.markdownDescription = def.description;
-        }
-    }
-    return jsonSchema;
-};

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/any.js

@@ -1,3 +0,0 @@
-export function parseAnyDef() {
-    return {};
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/array.js

@@ -1,25 +0,0 @@
-import { ZodFirstPartyTypeKind } from "zod";
-import { setResponseValueAndErrors } from "../errorMessages.js";
-import { parseDef } from "../parseDef.js";
-export function parseArrayDef(def, refs) {
-    const res = {
-        type: "array",
-    };
-    if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-        res.items = parseDef(def.type._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, "items"],
-        });
-    }
-    if (def.minLength) {
-        setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
-    }
-    if (def.maxLength) {
-        setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
-    }
-    if (def.exactLength) {
-        setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-        setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
-    }
-    return res;
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js

@@ -1,49 +0,0 @@
-import { setResponseValueAndErrors } from "../errorMessages.js";
-export function parseBigintDef(def, refs) {
-    const res = {
-        type: "integer",
-        format: "int64",
-    };
-    if (!def.checks)
-        return res;
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "min":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-                    }
-                    else {
-                        setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMinimum = true;
-                    }
-                    setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-                }
-                break;
-            case "max":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-                    }
-                    else {
-                        setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMaximum = true;
-                    }
-                    setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-                }
-                break;
-            case "multipleOf":
-                setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-                break;
-        }
-    }
-    return res;
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js

@@ -1,5 +0,0 @@
-export function parseBooleanDef() {
-    return {
-        type: "boolean",
-    };
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js

@@ -1,4 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export function parseBrandedDef(_def, refs) {
-    return parseDef(_def.type._def, refs);
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js

@@ -1,4 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export const parseCatchDef = (def, refs) => {
-    return parseDef(def.innerType._def, refs);
-};

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/date.js

@@ -1,46 +0,0 @@
-import { setResponseValueAndErrors } from "../errorMessages.js";
-export function parseDateDef(def, refs, overrideDateStrategy) {
-    const strategy = overrideDateStrategy ?? refs.dateStrategy;
-    if (Array.isArray(strategy)) {
-        return {
-            anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
-        };
-    }
-    switch (strategy) {
-        case "string":
-        case "format:date-time":
-            return {
-                type: "string",
-                format: "date-time",
-            };
-        case "format:date":
-            return {
-                type: "string",
-                format: "date",
-            };
-        case "integer":
-            return integerDateParser(def, refs);
-    }
-}
-const integerDateParser = (def, refs) => {
-    const res = {
-        type: "integer",
-        format: "unix-time",
-    };
-    if (refs.target === "openApi3") {
-        return res;
-    }
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "min":
-                setResponseValueAndErrors(res, "minimum", check.value, // This is in milliseconds
-                check.message, refs);
-                break;
-            case "max":
-                setResponseValueAndErrors(res, "maximum", check.value, // This is in milliseconds
-                check.message, refs);
-                break;
-        }
-    }
-    return res;
-};

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/default.js

@@ -1,7 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export function parseDefaultDef(_def, refs) {
-    return {
-        ...parseDef(_def.innerType._def, refs),
-        default: _def.defaultValue(),
-    };
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js

@@ -1,6 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export function parseEffectsDef(_def, refs) {
-    return refs.effectStrategy === "input"
-        ? parseDef(_def.schema._def, refs)
-        : {};
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js

@@ -1,6 +0,0 @@
-export function parseEnumDef(def) {
-    return {
-        type: "string",
-        enum: def.values,
-    };
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js

@@ -1,52 +0,0 @@
-import { parseDef } from "../parseDef.js";
-const isJsonSchema7AllOfType = (type) => {
-    if ("type" in type && type.type === "string")
-        return false;
-    return "allOf" in type;
-};
-export function parseIntersectionDef(def, refs) {
-    const allOf = [
-        parseDef(def.left._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, "allOf", "0"],
-        }),
-        parseDef(def.right._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, "allOf", "1"],
-        }),
-    ].filter((x) => !!x);
-    let unevaluatedProperties = refs.target === "jsonSchema2019-09"
-        ? { unevaluatedProperties: false }
-        : undefined;
-    const mergedAllOf = [];
-    // If either of the schemas is an allOf, merge them into a single allOf
-    allOf.forEach((schema) => {
-        if (isJsonSchema7AllOfType(schema)) {
-            mergedAllOf.push(...schema.allOf);
-            if (schema.unevaluatedProperties === undefined) {
-                // If one of the schemas has no unevaluatedProperties set,
-                // the merged schema should also have no unevaluatedProperties set
-                unevaluatedProperties = undefined;
-            }
-        }
-        else {
-            let nestedSchema = schema;
-            if ("additionalProperties" in schema &&
-                schema.additionalProperties === false) {
-                const { additionalProperties, ...rest } = schema;
-                nestedSchema = rest;
-            }
-            else {
-                // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
-                unevaluatedProperties = undefined;
-            }
-            mergedAllOf.push(nestedSchema);
-        }
-    });
-    return mergedAllOf.length
-        ? {
-            allOf: mergedAllOf,
-            ...unevaluatedProperties,
-        }
-        : undefined;
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js

@@ -1,21 +0,0 @@
-export function parseLiteralDef(def, refs) {
-    const parsedType = typeof def.value;
-    if (parsedType !== "bigint" &&
-        parsedType !== "number" &&
-        parsedType !== "boolean" &&
-        parsedType !== "string") {
-        return {
-            type: Array.isArray(def.value) ? "array" : "object",
-        };
-    }
-    if (refs.target === "openApi3") {
-        return {
-            type: parsedType === "bigint" ? "integer" : parsedType,
-            enum: [def.value],
-        };
-    }
-    return {
-        type: parsedType === "bigint" ? "integer" : parsedType,
-        const: def.value,
-    };
-}

package/.output/server/node_modules/zod-to-json-schema/dist/esm/parsers/map.js

@@ -1,25 +0,0 @@
-import { parseDef } from "../parseDef.js";
-import { parseRecordDef } from "./record.js";
-export function parseMapDef(def, refs) {
-    if (refs.mapStrategy === "record") {
-        return parseRecordDef(def, refs);
-    }
-    const keys = parseDef(def.keyType._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", "items", "0"],
-    }) || {};
-    const values = parseDef(def.valueType._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", "items", "1"],
-    }) || {};
-    return {
-        type: "array",
-        maxItems: 125,
-        items: {
-            type: "array",
-            items: [keys, values],
-            minItems: 2,
-            maxItems: 2,
-        },
-    };
-}