uomtiles 0.1.0

package/.output/server/node_modules/vue-bundle-renderer/dist/runtime.mjs

@@ -0,0 +1,278 @@
+import { withLeadingSlash } from "ufo";
+//#region src/runtime.ts
+function createRendererContext({ manifest, precomputed, buildAssetsURL, dependencySetsCacheSize }) {
+	if (!manifest && !precomputed) throw new Error("Either manifest or precomputed data must be provided");
+	const ctx = {
+		buildAssetsURL: buildAssetsURL || withLeadingSlash,
+		manifest,
+		precomputed,
+		updateManifest,
+		_dependencies: {},
+		_dependencySets: /* @__PURE__ */ new Map(),
+		_dependencySetsCacheSize: typeof dependencySetsCacheSize === "number" && Number.isFinite(dependencySetsCacheSize) && dependencySetsCacheSize > 0 ? Math.floor(dependencySetsCacheSize) : dependencySetsCacheSize === void 0 ? 1e3 : 0,
+		_entrypoints: [],
+		_renderedCache: /* @__PURE__ */ new WeakMap()
+	};
+	function updateManifest(manifest) {
+		ctx.manifest = manifest;
+		ctx._dependencies = {};
+		ctx._dependencySets.clear();
+		ctx._renderedCache = /* @__PURE__ */ new WeakMap();
+		const entrypoints = [];
+		for (const id in manifest) if (manifest[id].isEntry) entrypoints.push(id);
+		ctx._entrypoints = entrypoints;
+	}
+	if (precomputed) {
+		ctx._dependencies = precomputed.dependencies;
+		ctx._entrypoints = precomputed.entrypoints;
+	} else if (manifest) updateManifest(manifest);
+	return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+	if (rendererContext._dependencies[id]) return rendererContext._dependencies[id];
+	const dependencies = rendererContext._dependencies[id] = {
+		scripts: {},
+		styles: {},
+		preload: {},
+		prefetch: {}
+	};
+	if (!rendererContext.manifest) return dependencies;
+	const meta = rendererContext.manifest[id];
+	if (!meta) return dependencies;
+	if (meta.file) {
+		dependencies.preload[id] = meta;
+		if (meta.isEntry || meta.sideEffects) dependencies.scripts[id] = meta;
+	}
+	for (const css of meta.css || []) dependencies.styles[css] = dependencies.preload[css] = dependencies.prefetch[css] = rendererContext.manifest[css];
+	for (const asset of meta.assets || []) dependencies.preload[asset] = dependencies.prefetch[asset] = rendererContext.manifest[asset];
+	if (meta.imports) for (const depId of meta.imports) {
+		const depDeps = getModuleDependencies(depId, rendererContext);
+		Object.assign(dependencies.styles, depDeps.styles);
+		Object.assign(dependencies.preload, depDeps.preload);
+		Object.assign(dependencies.prefetch, depDeps.prefetch);
+	}
+	const filteredPreload = {};
+	for (const id in dependencies.preload) {
+		const dep = dependencies.preload[id];
+		if (dep.preload) filteredPreload[id] = dep;
+	}
+	dependencies.preload = filteredPreload;
+	return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+	const cacheSize = rendererContext._dependencySetsCacheSize;
+	const useCache = cacheSize > 0;
+	let cacheKey = "";
+	if (useCache) {
+		if (ids.size <= 1) for (const id of ids) cacheKey = id;
+		else cacheKey = [...ids].sort().join(",");
+		const cached = rendererContext._dependencySets.get(cacheKey);
+		if (cached !== void 0) {
+			if (rendererContext._dependencySets.size >= cacheSize) {
+				rendererContext._dependencySets.delete(cacheKey);
+				rendererContext._dependencySets.set(cacheKey, cached);
+			}
+			return cached;
+		}
+	}
+	const allDeps = {
+		scripts: {},
+		styles: {},
+		preload: {},
+		prefetch: {}
+	};
+	for (const id of ids) {
+		const deps = getModuleDependencies(id, rendererContext);
+		Object.assign(allDeps.scripts, deps.scripts);
+		Object.assign(allDeps.styles, deps.styles);
+		Object.assign(allDeps.preload, deps.preload);
+		Object.assign(allDeps.prefetch, deps.prefetch);
+		const dynamicImports = rendererContext.manifest?.[id]?.dynamicImports || rendererContext.precomputed?.modules[id]?.dynamicImports;
+		if (dynamicImports) for (const dynamicDepId of dynamicImports) {
+			const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+			Object.assign(allDeps.prefetch, dynamicDeps.scripts);
+			Object.assign(allDeps.prefetch, dynamicDeps.styles);
+			Object.assign(allDeps.prefetch, dynamicDeps.preload);
+		}
+	}
+	const mergedPreload = allDeps.preload;
+	const styles = allDeps.styles;
+	const filteredPrefetch = {};
+	for (const id in allDeps.prefetch) {
+		const dep = allDeps.prefetch[id];
+		if (dep.prefetch && !(id in mergedPreload) && !(id in styles)) filteredPrefetch[id] = dep;
+	}
+	allDeps.prefetch = filteredPrefetch;
+	const filteredPreload = {};
+	for (const id in mergedPreload) if (!(id in styles)) filteredPreload[id] = mergedPreload[id];
+	allDeps.preload = filteredPreload;
+	if (useCache) {
+		rendererContext._dependencySets.set(cacheKey, allDeps);
+		if (rendererContext._dependencySets.size > cacheSize) {
+			const oldest = rendererContext._dependencySets.keys().next().value;
+			if (oldest !== void 0) rendererContext._dependencySets.delete(oldest);
+		}
+	}
+	return allDeps;
+}
+function getRequestDependencies(ssrContext, rendererContext, options) {
+	const excluded = options?.exclude ? new Set(options.exclude) : void 0;
+	const hasExcluded = excluded && excluded.size > 0;
+	if (!hasExcluded && ssrContext._requestDependencies) return ssrContext._requestDependencies;
+	let ids;
+	const requestIds = ssrContext.modules || ssrContext._registeredComponents;
+	if (hasExcluded) {
+		ids = /* @__PURE__ */ new Set();
+		for (const id of rendererContext._entrypoints) if (!excluded.has(id)) ids.add(id);
+		if (requestIds) {
+			for (const id of requestIds) if (!excluded.has(id)) ids.add(id);
+		}
+	} else {
+		ids = new Set(rendererContext._entrypoints);
+		if (requestIds) for (const id of requestIds) ids.add(id);
+	}
+	const deps = getAllDependencies(ids, rendererContext);
+	if (!hasExcluded) ssrContext._requestDependencies = deps;
+	return deps;
+}
+function getRenderedOutputs(rendererContext, deps) {
+	let entry = rendererContext._renderedCache.get(deps);
+	if (!entry) {
+		entry = {};
+		rendererContext._renderedCache.set(deps, entry);
+	}
+	return entry;
+}
+function renderStyles(ssrContext, rendererContext) {
+	const deps = getRequestDependencies(ssrContext, rendererContext);
+	const rendered = getRenderedOutputs(rendererContext, deps);
+	if (rendered.styles !== void 0) return rendered.styles;
+	const { styles } = deps;
+	let result = "";
+	for (const key in styles) {
+		const resource = styles[key];
+		result += `<link rel="stylesheet" href="${rendererContext.buildAssetsURL(resource.file)}" crossorigin>`;
+	}
+	rendered.styles = result;
+	return result;
+}
+function getResources(ssrContext, rendererContext) {
+	return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext, options) {
+	const deps = getRequestDependencies(ssrContext, rendererContext, options);
+	const rendered = getRenderedOutputs(rendererContext, deps);
+	if (rendered.hints !== void 0) return rendered.hints;
+	const { preload, prefetch } = deps;
+	let result = "";
+	for (const key in preload) {
+		const resource = preload[key];
+		const href = rendererContext.buildAssetsURL(resource.file);
+		const rel = resource.module ? "modulepreload" : "preload";
+		const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+		if (resource.resourceType && resource.mimeType) result += `<link rel="${rel}" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+		else if (resource.resourceType) result += `<link rel="${rel}" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+		else result += `<link rel="${rel}"${crossorigin} href="${href}">`;
+	}
+	for (const key in prefetch) {
+		const resource = prefetch[key];
+		const href = rendererContext.buildAssetsURL(resource.file);
+		const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+		if (resource.resourceType && resource.mimeType) result += `<link rel="prefetch" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+		else if (resource.resourceType) result += `<link rel="prefetch" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+		else result += `<link rel="prefetch"${crossorigin} href="${href}">`;
+	}
+	rendered.hints = result;
+	return result;
+}
+const NON_ASCII_RE = /[^\0-\u007F]+/g;
+function renderResourceHeaders(ssrContext, rendererContext, options) {
+	const deps = getRequestDependencies(ssrContext, rendererContext, options);
+	const rendered = getRenderedOutputs(rendererContext, deps);
+	if (rendered.headerLink !== void 0) return { link: rendered.headerLink };
+	const { preload, prefetch } = deps;
+	const links = [];
+	for (const key in preload) {
+		const resource = preload[key];
+		let header = `<${rendererContext.buildAssetsURL(resource.file).replace(NON_ASCII_RE, encodeURIComponent)}>; rel="${resource.module ? "modulepreload" : "preload"}"`;
+		if (resource.resourceType) header += `; as="${resource.resourceType}"`;
+		if (resource.mimeType) header += `; type="${resource.mimeType}"`;
+		if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) header += "; crossorigin";
+		links.push(header);
+	}
+	for (const key in prefetch) {
+		const resource = prefetch[key];
+		let header = `<${rendererContext.buildAssetsURL(resource.file).replace(NON_ASCII_RE, encodeURIComponent)}>; rel="prefetch"`;
+		if (resource.resourceType) header += `; as="${resource.resourceType}"`;
+		if (resource.mimeType) header += `; type="${resource.mimeType}"`;
+		if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) header += "; crossorigin";
+		links.push(header);
+	}
+	rendered.headerLink = links.join(", ");
+	return { link: rendered.headerLink };
+}
+function getPreloadLinks(ssrContext, rendererContext, options) {
+	const { preload } = getRequestDependencies(ssrContext, rendererContext, options);
+	const result = [];
+	for (const key in preload) {
+		const resource = preload[key];
+		result.push({
+			rel: resource.module ? "modulepreload" : "preload",
+			as: resource.resourceType,
+			type: resource.mimeType ?? null,
+			crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+			href: rendererContext.buildAssetsURL(resource.file)
+		});
+	}
+	return result;
+}
+function getPrefetchLinks(ssrContext, rendererContext, options) {
+	const { prefetch } = getRequestDependencies(ssrContext, rendererContext, options);
+	const result = [];
+	for (const key in prefetch) {
+		const resource = prefetch[key];
+		result.push({
+			rel: "prefetch",
+			as: resource.resourceType,
+			type: resource.mimeType ?? null,
+			crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+			href: rendererContext.buildAssetsURL(resource.file)
+		});
+	}
+	return result;
+}
+function renderScripts(ssrContext, rendererContext) {
+	const deps = getRequestDependencies(ssrContext, rendererContext);
+	const rendered = getRenderedOutputs(rendererContext, deps);
+	if (rendered.scripts !== void 0) return rendered.scripts;
+	const { scripts } = deps;
+	let result = "";
+	for (const key in scripts) {
+		const resource = scripts[key];
+		if (resource.module) result += `<script type="module" src="${rendererContext.buildAssetsURL(resource.file)}" crossorigin><\/script>`;
+		else result += `<script src="${rendererContext.buildAssetsURL(resource.file)}" defer crossorigin><\/script>`;
+	}
+	rendered.scripts = result;
+	return result;
+}
+function createRenderer(createApp, renderOptions) {
+	const rendererContext = createRendererContext(renderOptions);
+	return {
+		rendererContext,
+		async renderToString(ssrContext) {
+			ssrContext._registeredComponents = ssrContext._registeredComponents || /* @__PURE__ */ new Set();
+			const app = await (await Promise.resolve(createApp).then((r) => "default" in r ? r.default : r))(ssrContext);
+			const html = await renderOptions.renderToString(app, ssrContext);
+			const wrap = (fn) => () => fn(ssrContext, rendererContext);
+			return {
+				html,
+				renderResourceHeaders: wrap(renderResourceHeaders),
+				renderResourceHints: wrap(renderResourceHints),
+				renderStyles: wrap(renderStyles),
+				renderScripts: wrap(renderScripts)
+			};
+		}
+	};
+}
+//#endregion
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };

package/.output/server/node_modules/vue-bundle-renderer/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "vue-bundle-renderer",
+  "version": "2.3.2",
+  "description": "Bundle Renderer for Vue 3.0",
+  "repository": {
+    "type": "git",
+    "url": "nuxt-contrib/vue-bundle-renderer"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.mts",
+      "import": "./dist/runtime.mjs",
+      "require": "./dist/runtime.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist",
+    "runtime.d.ts"
+  ],
+  "dependencies": {
+    "ufo": "^1.6.4"
+  },
+  "devDependencies": {
+    "@codspeed/vitest-plugin": "^5.7.1",
+    "@nuxt/eslint-config": "^1.16.0",
+    "@types/node": "^24.13.3",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^10.8.0",
+    "pkg-pr-new": "^0.0.86",
+    "std-env": "^4.2.0",
+    "tsdown": "0.22.14",
+    "typescript": "^6.0.3",
+    "vite": "^8.2.0",
+    "vitest": "4.1.10",
+    "vue": "3.5.40"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "vitest",
+    "lint": "eslint src",
+    "test": "pnpm lint && pnpm vitest run --coverage && tsc --noEmit",
+    "bench": "vitest bench"
+  }
+}

package/.output/server/node_modules/yocto-queue/index.js

@@ -0,0 +1,90 @@
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+
+class Node {
+	value;
+	next;
+
+	constructor(value) {
+		this.value = value;
+	}
+}
+
+export default class Queue {
+	#head;
+	#tail;
+	#size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+
+		this.#size++;
+	}
+
+	dequeue() {
+		const current = this.#head;
+		if (!current) {
+			return;
+		}
+
+		this.#head = this.#head.next;
+		this.#size--;
+
+		// Clean up tail reference when queue becomes empty
+		if (!this.#head) {
+			this.#tail = undefined;
+		}
+
+		return current.value;
+	}
+
+	peek() {
+		if (!this.#head) {
+			return;
+		}
+
+		return this.#head.value;
+
+		// TODO: Node.js 18.
+		// return this.#head?.value;
+	}
+
+	clear() {
+		this.#head = undefined;
+		this.#tail = undefined;
+		this.#size = 0;
+	}
+
+	get size() {
+		return this.#size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this.#head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+
+	* drain() {
+		while (this.#head) {
+			yield this.dequeue();
+		}
+	}
+}

package/.output/server/node_modules/yocto-queue/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "yocto-queue",
+  "version": "1.2.2",
+  "description": "Tiny queue data structure",
+  "license": "MIT",
+  "repository": "sindresorhus/yocto-queue",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": "./index.js",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12.20"
+  },
+  "scripts": {
+    "//test": "xo && ava && tsd",
+    "test": "ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "queue",
+    "data",
+    "structure",
+    "algorithm",
+    "queues",
+    "queuing",
+    "list",
+    "array",
+    "linkedlist",
+    "fifo",
+    "enqueue",
+    "dequeue",
+    "data-structure"
+  ],
+  "devDependencies": {
+    "ava": "^3.15.0",
+    "tsd": "^0.17.0",
+    "xo": "^0.44.0"
+  }
+}

package/.output/server/node_modules/zod/index.js

@@ -0,0 +1,4 @@
+import * as z from "./v4/classic/external.js";
+export * from "./v4/classic/external.js";
+export { z };
+export default z;

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

@@ -0,0 +1,135 @@
+{
+  "name": "zod",
+  "version": "4.4.3",
+  "type": "module",
+  "license": "MIT",
+  "author": "Colin McDonnell <zod@colinhacks.com>",
+  "description": "TypeScript-first schema declaration and validation library with static type inference",
+  "homepage": "https://zod.dev",
+  "llms": "https://zod.dev/llms.txt",
+  "llmsFull": "https://zod.dev/llms-full.txt",
+  "mcpServer": "https://mcp.inkeep.com/zod/mcp",
+  "funding": "https://github.com/sponsors/colinhacks",
+  "sideEffects": false,
+  "files": [
+    "src",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs",
+    "**/*.d.ts",
+    "**/*.d.mts",
+    "**/*.d.cts",
+    "**/package.json"
+  ],
+  "keywords": [
+    "typescript",
+    "schema",
+    "validation",
+    "type",
+    "inference"
+  ],
+  "main": "./index.cjs",
+  "types": "./index.d.cts",
+  "module": "./index.js",
+  "zshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts",
+      "./mini": "./src/mini/index.ts",
+      "./locales": "./src/locales/index.ts",
+      "./v3": "./src/v3/index.ts",
+      "./v4": "./src/v4/index.ts",
+      "./v4-mini": "./src/v4-mini/index.ts",
+      "./v4/mini": "./src/v4/mini/index.ts",
+      "./v4/core": "./src/v4/core/index.ts",
+      "./v4/locales": "./src/v4/locales/index.ts",
+      "./v4/locales/*": "./src/v4/locales/*"
+    },
+    "conditions": {
+      "@zod/source": "src"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zod/source": "./src/index.ts",
+      "types": "./index.d.cts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./mini": {
+      "@zod/source": "./src/mini/index.ts",
+      "types": "./mini/index.d.cts",
+      "import": "./mini/index.js",
+      "require": "./mini/index.cjs"
+    },
+    "./locales": {
+      "@zod/source": "./src/locales/index.ts",
+      "types": "./locales/index.d.cts",
+      "import": "./locales/index.js",
+      "require": "./locales/index.cjs"
+    },
+    "./v3": {
+      "@zod/source": "./src/v3/index.ts",
+      "types": "./v3/index.d.cts",
+      "import": "./v3/index.js",
+      "require": "./v3/index.cjs"
+    },
+    "./v4": {
+      "@zod/source": "./src/v4/index.ts",
+      "types": "./v4/index.d.cts",
+      "import": "./v4/index.js",
+      "require": "./v4/index.cjs"
+    },
+    "./v4-mini": {
+      "@zod/source": "./src/v4-mini/index.ts",
+      "types": "./v4-mini/index.d.cts",
+      "import": "./v4-mini/index.js",
+      "require": "./v4-mini/index.cjs"
+    },
+    "./v4/mini": {
+      "@zod/source": "./src/v4/mini/index.ts",
+      "types": "./v4/mini/index.d.cts",
+      "import": "./v4/mini/index.js",
+      "require": "./v4/mini/index.cjs"
+    },
+    "./v4/core": {
+      "@zod/source": "./src/v4/core/index.ts",
+      "types": "./v4/core/index.d.cts",
+      "import": "./v4/core/index.js",
+      "require": "./v4/core/index.cjs"
+    },
+    "./v4/locales": {
+      "@zod/source": "./src/v4/locales/index.ts",
+      "types": "./v4/locales/index.d.cts",
+      "import": "./v4/locales/index.js",
+      "require": "./v4/locales/index.cjs"
+    },
+    "./v4/locales/*": {
+      "@zod/source": "./src/v4/locales/*",
+      "types": "./v4/locales/*",
+      "import": "./v4/locales/*",
+      "require": "./v4/locales/*"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/colinhacks/zod.git"
+  },
+  "bugs": {
+    "url": "https://github.com/colinhacks/zod/issues"
+  },
+  "support": {
+    "backing": {
+      "npm-funding": true
+    }
+  },
+  "scripts": {
+    "clean": "git clean -xdf . -e node_modules",
+    "build": "zshy --project tsconfig.build.json",
+    "postbuild": "tsx ../../scripts/write-stub-package-jsons.ts && pnpm biome check --write .",
+    "test:watch": "pnpm vitest",
+    "test": "pnpm vitest run",
+    "prepublishOnly": "tsx ../../scripts/check-versions.ts"
+  }
+}

package/.output/server/node_modules/zod/v4/classic/checks.js

@@ -0,0 +1 @@
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from "../core/index.js";

package/.output/server/node_modules/zod/v4/classic/coerce.js

@@ -0,0 +1,17 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export function string(params) {
+    return core._coercedString(schemas.ZodString, params);
+}
+export function number(params) {
+    return core._coercedNumber(schemas.ZodNumber, params);
+}
+export function boolean(params) {
+    return core._coercedBoolean(schemas.ZodBoolean, params);
+}
+export function bigint(params) {
+    return core._coercedBigint(schemas.ZodBigInt, params);
+}
+export function date(params) {
+    return core._coercedDate(schemas.ZodDate, params);
+}

package/.output/server/node_modules/zod/v4/classic/compat.js

@@ -0,0 +1,31 @@
+// Zod 3 compat layer
+import * as core from "../core/index.js";
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+export const ZodIssueCode = {
+    invalid_type: "invalid_type",
+    too_big: "too_big",
+    too_small: "too_small",
+    invalid_format: "invalid_format",
+    not_multiple_of: "not_multiple_of",
+    unrecognized_keys: "unrecognized_keys",
+    invalid_union: "invalid_union",
+    invalid_key: "invalid_key",
+    invalid_element: "invalid_element",
+    invalid_value: "invalid_value",
+    custom: "custom",
+};
+export { $brand, config } from "../core/index.js";
+/** @deprecated Use `z.config(params)` instead. */
+export function setErrorMap(map) {
+    core.config({
+        customError: map,
+    });
+}
+/** @deprecated Use `z.config()` instead. */
+export function getErrorMap() {
+    return core.config().customError;
+}
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export var ZodFirstPartyTypeKind;
+(function (ZodFirstPartyTypeKind) {
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));