ccusage 11.0.0 → 11.0.2

package/dist/core-DHCbAXJf.js

@@ -1,693 +0,0 @@
-//#region node_modules/zod/dist/esm/v4/core/util.js
-function getEnumValues(entries) {
-	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-	const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
-	return values;
-}
-function cached(getter) {
-	const set = false;
-	return { get value() {
-		if (!set) {
-			const value = getter();
-			Object.defineProperty(this, "value", { value });
-			return value;
-		}
-		throw new Error("cached value already set");
-	} };
-}
-const allowsEval = cached(() => {
-	try {
-		const F = Function;
-		new F("");
-		return true;
-	} catch (_) {
-		return false;
-	}
-});
-const NUMBER_FORMAT_RANGES = {
-	safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
-	int32: [-2147483648, 2147483647],
-	uint32: [0, 4294967295],
-	float32: [-34028234663852886e22, 34028234663852886e22],
-	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
-};
-
-//#endregion
-//#region node_modules/zod/dist/esm/v4/core/registries.js
-const $output = Symbol("ZodOutput");
-const $input = Symbol("ZodInput");
-var $ZodRegistry = class {
-	constructor() {
-		this._map = /* @__PURE__ */ new WeakMap();
-		this._idmap = /* @__PURE__ */ new Map();
-	}
-	add(schema, ..._meta) {
-		const meta = _meta[0];
-		this._map.set(schema, meta);
-		if (meta && typeof meta === "object" && "id" in meta) {
-			if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
-			this._idmap.set(meta.id, schema);
-		}
-		return this;
-	}
-	remove(schema) {
-		this._map.delete(schema);
-		return this;
-	}
-	get(schema) {
-		const p = schema._zod.parent;
-		if (p) {
-			const pm = { ...this.get(p) ?? {} };
-			delete pm.id;
-			return {
-				...pm,
-				...this._map.get(schema)
-			};
-		}
-		return this._map.get(schema);
-	}
-	has(schema) {
-		return this._map.has(schema);
-	}
-};
-function registry() {
-	return new $ZodRegistry();
-}
-const globalRegistry = /* @__PURE__ */ registry();
-
-//#endregion
-//#region node_modules/zod/dist/esm/v4/core/to-json-schema.js
-var JSONSchemaGenerator = class {
-	constructor(params) {
-		this.counter = 0;
-		this.metadataRegistry = params?.metadata ?? globalRegistry;
-		this.target = params?.target ?? "draft-2020-12";
-		this.unrepresentable = params?.unrepresentable ?? "throw";
-		this.override = params?.override ?? (() => {});
-		this.io = params?.io ?? "output";
-		this.seen = /* @__PURE__ */ new Map();
-	}
-	process(schema, _params = {
-		path: [],
-		schemaPath: []
-	}) {
-		var _a;
-		const def = schema._zod.def;
-		const formatMap = {
-			guid: "uuid",
-			url: "uri",
-			datetime: "date-time",
-			json_string: "json-string",
-			regex: ""
-		};
-		const seen = this.seen.get(schema);
-		if (seen) {
-			seen.count++;
-			const isCycle = _params.schemaPath.includes(schema);
-			if (isCycle) seen.cycle = _params.path;
-			return seen.schema;
-		}
-		const result = {
-			schema: {},
-			count: 1,
-			cycle: void 0
-		};
-		this.seen.set(schema, result);
-		if (schema._zod.toJSONSchema) result.schema = schema._zod.toJSONSchema();
-		const params = {
-			..._params,
-			schemaPath: [..._params.schemaPath, schema],
-			path: _params.path
-		};
-		const parent = schema._zod.parent;
-		if (parent) {
-			result.ref = parent;
-			this.process(parent, params);
-			this.seen.get(parent).isParent = true;
-		} else {
-			const _json = result.schema;
-			switch (def.type) {
-				case "string": {
-					const json = _json;
-					json.type = "string";
-					const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
-					if (typeof minimum === "number") json.minLength = minimum;
-					if (typeof maximum === "number") json.maxLength = maximum;
-					if (format) {
-						json.format = formatMap[format] ?? format;
-						if (json.format === "") delete json.format;
-					}
-					if (contentEncoding) json.contentEncoding = contentEncoding;
-					if (patterns && patterns.size > 0) {
-						const regexes = [...patterns];
-						if (regexes.length === 1) json.pattern = regexes[0].source;
-						else if (regexes.length > 1) result.schema.allOf = [...regexes.map((regex) => ({
-							...this.target === "draft-7" ? { type: "string" } : {},
-							pattern: regex.source
-						}))];
-					}
-					break;
-				}
-				case "number": {
-					const json = _json;
-					const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-					if (typeof format === "string" && format.includes("int")) json.type = "integer";
-					else json.type = "number";
-					if (typeof exclusiveMinimum === "number") json.exclusiveMinimum = exclusiveMinimum;
-					if (typeof minimum === "number") {
-						json.minimum = minimum;
-						if (typeof exclusiveMinimum === "number") if (exclusiveMinimum >= minimum) delete json.minimum;
-						else delete json.exclusiveMinimum;
-					}
-					if (typeof exclusiveMaximum === "number") json.exclusiveMaximum = exclusiveMaximum;
-					if (typeof maximum === "number") {
-						json.maximum = maximum;
-						if (typeof exclusiveMaximum === "number") if (exclusiveMaximum <= maximum) delete json.maximum;
-						else delete json.exclusiveMaximum;
-					}
-					if (typeof multipleOf === "number") json.multipleOf = multipleOf;
-					break;
-				}
-				case "boolean": {
-					const json = _json;
-					json.type = "boolean";
-					break;
-				}
-				case "bigint": {
-					if (this.unrepresentable === "throw") throw new Error("BigInt cannot be represented in JSON Schema");
-					break;
-				}
-				case "symbol": {
-					if (this.unrepresentable === "throw") throw new Error("Symbols cannot be represented in JSON Schema");
-					break;
-				}
-				case "undefined": {
-					const json = _json;
-					json.type = "null";
-					break;
-				}
-				case "null": {
-					_json.type = "null";
-					break;
-				}
-				case "any": break;
-				case "unknown": break;
-				case "never": {
-					_json.not = {};
-					break;
-				}
-				case "void": {
-					if (this.unrepresentable === "throw") throw new Error("Void cannot be represented in JSON Schema");
-					break;
-				}
-				case "date": {
-					if (this.unrepresentable === "throw") throw new Error("Date cannot be represented in JSON Schema");
-					break;
-				}
-				case "array": {
-					const json = _json;
-					const { minimum, maximum } = schema._zod.bag;
-					if (typeof minimum === "number") json.minItems = minimum;
-					if (typeof maximum === "number") json.maxItems = maximum;
-					json.type = "array";
-					json.items = this.process(def.element, {
-						...params,
-						path: [...params.path, "items"]
-					});
-					break;
-				}
-				case "object": {
-					const json = _json;
-					json.type = "object";
-					json.properties = {};
-					const shape = def.shape;
-					for (const key in shape) json.properties[key] = this.process(shape[key], {
-						...params,
-						path: [
-							...params.path,
-							"properties",
-							key
-						]
-					});
-					const allKeys = new Set(Object.keys(shape));
-					const requiredKeys = new Set([...allKeys].filter((key) => {
-						const v = def.shape[key]._zod;
-						if (this.io === "input") return v.optin === void 0;
-						else return v.optout === void 0;
-					}));
-					if (requiredKeys.size > 0) json.required = Array.from(requiredKeys);
-					if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
-					else if (!def.catchall) {
-						if (this.io === "output") json.additionalProperties = false;
-					} else if (def.catchall) json.additionalProperties = this.process(def.catchall, {
-						...params,
-						path: [...params.path, "additionalProperties"]
-					});
-					break;
-				}
-				case "union": {
-					const json = _json;
-					json.anyOf = def.options.map((x, i) => this.process(x, {
-						...params,
-						path: [
-							...params.path,
-							"anyOf",
-							i
-						]
-					}));
-					break;
-				}
-				case "intersection": {
-					const json = _json;
-					const a = this.process(def.left, {
-						...params,
-						path: [
-							...params.path,
-							"allOf",
-							0
-						]
-					});
-					const b = this.process(def.right, {
-						...params,
-						path: [
-							...params.path,
-							"allOf",
-							1
-						]
-					});
-					const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
-					const allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
-					json.allOf = allOf;
-					break;
-				}
-				case "tuple": {
-					const json = _json;
-					json.type = "array";
-					const prefixItems = def.items.map((x, i) => this.process(x, {
-						...params,
-						path: [
-							...params.path,
-							"prefixItems",
-							i
-						]
-					}));
-					if (this.target === "draft-2020-12") json.prefixItems = prefixItems;
-					else json.items = prefixItems;
-					if (def.rest) {
-						const rest = this.process(def.rest, {
-							...params,
-							path: [...params.path, "items"]
-						});
-						if (this.target === "draft-2020-12") json.items = rest;
-						else json.additionalItems = rest;
-					}
-					if (def.rest) json.items = this.process(def.rest, {
-						...params,
-						path: [...params.path, "items"]
-					});
-					const { minimum, maximum } = schema._zod.bag;
-					if (typeof minimum === "number") json.minItems = minimum;
-					if (typeof maximum === "number") json.maxItems = maximum;
-					break;
-				}
-				case "record": {
-					const json = _json;
-					json.type = "object";
-					json.propertyNames = this.process(def.keyType, {
-						...params,
-						path: [...params.path, "propertyNames"]
-					});
-					json.additionalProperties = this.process(def.valueType, {
-						...params,
-						path: [...params.path, "additionalProperties"]
-					});
-					break;
-				}
-				case "map": {
-					if (this.unrepresentable === "throw") throw new Error("Map cannot be represented in JSON Schema");
-					break;
-				}
-				case "set": {
-					if (this.unrepresentable === "throw") throw new Error("Set cannot be represented in JSON Schema");
-					break;
-				}
-				case "enum": {
-					const json = _json;
-					const values = getEnumValues(def.entries);
-					if (values.every((v) => typeof v === "number")) json.type = "number";
-					if (values.every((v) => typeof v === "string")) json.type = "string";
-					json.enum = values;
-					break;
-				}
-				case "literal": {
-					const json = _json;
-					const vals = [];
-					for (const val of def.values) if (val === void 0) {
-						if (this.unrepresentable === "throw") throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-					} else if (typeof val === "bigint") if (this.unrepresentable === "throw") throw new Error("BigInt literals cannot be represented in JSON Schema");
-					else vals.push(Number(val));
-					else vals.push(val);
-					if (vals.length === 0) {} else if (vals.length === 1) {
-						const val = vals[0];
-						json.type = val === null ? "null" : typeof val;
-						json.const = val;
-					} else {
-						if (vals.every((v) => typeof v === "number")) json.type = "number";
-						if (vals.every((v) => typeof v === "string")) json.type = "string";
-						if (vals.every((v) => typeof v === "boolean")) json.type = "string";
-						if (vals.every((v) => v === null)) json.type = "null";
-						json.enum = vals;
-					}
-					break;
-				}
-				case "file": {
-					const json = _json;
-					const file = {
-						type: "string",
-						format: "binary",
-						contentEncoding: "binary"
-					};
-					const { minimum, maximum, mime } = schema._zod.bag;
-					if (minimum !== void 0) file.minLength = minimum;
-					if (maximum !== void 0) file.maxLength = maximum;
-					if (mime) if (mime.length === 1) {
-						file.contentMediaType = mime[0];
-						Object.assign(json, file);
-					} else json.anyOf = mime.map((m) => {
-						const mFile = {
-							...file,
-							contentMediaType: m
-						};
-						return mFile;
-					});
-					else Object.assign(json, file);
-					break;
-				}
-				case "transform": {
-					if (this.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
-					break;
-				}
-				case "nullable": {
-					const inner = this.process(def.innerType, params);
-					_json.anyOf = [inner, { type: "null" }];
-					break;
-				}
-				case "nonoptional": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					break;
-				}
-				case "success": {
-					const json = _json;
-					json.type = "boolean";
-					break;
-				}
-				case "default": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					_json.default = def.defaultValue;
-					break;
-				}
-				case "prefault": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					if (this.io === "input") _json._prefault = def.defaultValue;
-					break;
-				}
-				case "catch": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					let catchValue;
-					try {
-						catchValue = def.catchValue(void 0);
-					} catch {
-						throw new Error("Dynamic catch values are not supported in JSON Schema");
-					}
-					_json.default = catchValue;
-					break;
-				}
-				case "nan": {
-					if (this.unrepresentable === "throw") throw new Error("NaN cannot be represented in JSON Schema");
-					break;
-				}
-				case "template_literal": {
-					const json = _json;
-					const pattern = schema._zod.pattern;
-					if (!pattern) throw new Error("Pattern not found in template literal");
-					json.type = "string";
-					json.pattern = pattern.source;
-					break;
-				}
-				case "pipe": {
-					const innerType = this.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-					this.process(innerType, params);
-					result.ref = innerType;
-					break;
-				}
-				case "readonly": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					_json.readOnly = true;
-					break;
-				}
-				case "promise": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					break;
-				}
-				case "optional": {
-					this.process(def.innerType, params);
-					result.ref = def.innerType;
-					break;
-				}
-				case "lazy": {
-					const innerType = schema._zod.innerType;
-					this.process(innerType, params);
-					result.ref = innerType;
-					break;
-				}
-				case "custom": {
-					if (this.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
-					break;
-				}
-				default: {}
-			}
-		}
-		const meta = this.metadataRegistry.get(schema);
-		if (meta) Object.assign(result.schema, meta);
-		if (this.io === "input" && isTransforming(schema)) {
-			delete result.schema.examples;
-			delete result.schema.default;
-		}
-		if (this.io === "input" && result.schema._prefault) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
-		delete result.schema._prefault;
-		const _result = this.seen.get(schema);
-		return _result.schema;
-	}
-	emit(schema, _params) {
-		const params = {
-			cycles: _params?.cycles ?? "ref",
-			reused: _params?.reused ?? "inline",
-			external: _params?.external ?? void 0
-		};
-		const root = this.seen.get(schema);
-		if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
-		const makeURI = (entry) => {
-			const defsSegment = this.target === "draft-2020-12" ? "$defs" : "definitions";
-			if (params.external) {
-				const externalId = params.external.registry.get(entry[0])?.id;
-				if (externalId) return { ref: params.external.uri(externalId) };
-				const id = entry[1].defId ?? entry[1].schema.id ?? `schema${this.counter++}`;
-				entry[1].defId = id;
-				return {
-					defId: id,
-					ref: `${params.external.uri("__shared")}#/${defsSegment}/${id}`
-				};
-			}
-			if (entry[1] === root) return { ref: "#" };
-			const uriPrefix = `#`;
-			const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
-			const defId = entry[1].schema.id ?? `__schema${this.counter++}`;
-			return {
-				defId,
-				ref: defUriPrefix + defId
-			};
-		};
-		const extractToDef = (entry) => {
-			if (entry[1].schema.$ref) return;
-			const seen = entry[1];
-			const { ref, defId } = makeURI(entry);
-			seen.def = { ...seen.schema };
-			if (defId) seen.defId = defId;
-			const schema$1 = seen.schema;
-			for (const key in schema$1) delete schema$1[key];
-			schema$1.$ref = ref;
-		};
-		for (const entry of this.seen.entries()) {
-			const seen = entry[1];
-			if (schema === entry[0]) {
-				extractToDef(entry);
-				continue;
-			}
-			if (params.external) {
-				const ext = params.external.registry.get(entry[0])?.id;
-				if (schema !== entry[0] && ext) {
-					extractToDef(entry);
-					continue;
-				}
-			}
-			const id = this.metadataRegistry.get(entry[0])?.id;
-			if (id) {
-				extractToDef(entry);
-				continue;
-			}
-			if (seen.cycle) {
-				if (params.cycles === "throw") throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
-
-Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
-				else if (params.cycles === "ref") extractToDef(entry);
-				continue;
-			}
-			if (seen.count > 1) {
-				if (params.reused === "ref") {
-					extractToDef(entry);
-					continue;
-				}
-			}
-		}
-		const flattenRef = (zodSchema, params$1) => {
-			const seen = this.seen.get(zodSchema);
-			const schema$1 = seen.def ?? seen.schema;
-			const _cached = { ...schema$1 };
-			if (seen.ref === null) return;
-			const ref = seen.ref;
-			seen.ref = null;
-			if (ref) {
-				flattenRef(ref, params$1);
-				const refSchema = this.seen.get(ref).schema;
-				if (refSchema.$ref && params$1.target === "draft-7") {
-					schema$1.allOf = schema$1.allOf ?? [];
-					schema$1.allOf.push(refSchema);
-				} else {
-					Object.assign(schema$1, refSchema);
-					Object.assign(schema$1, _cached);
-				}
-			}
-			if (!seen.isParent) this.override({
-				zodSchema,
-				jsonSchema: schema$1
-			});
-		};
-		for (const entry of [...this.seen.entries()].reverse()) flattenRef(entry[0], { target: this.target });
-		const result = {};
-		if (this.target === "draft-2020-12") result.$schema = "https://json-schema.org/draft/2020-12/schema";
-		else if (this.target === "draft-7") result.$schema = "http://json-schema.org/draft-07/schema#";
-		else console.warn(`Invalid target: ${this.target}`);
-		Object.assign(result, root.def);
-		const defs = params.external?.defs ?? {};
-		for (const entry of this.seen.entries()) {
-			const seen = entry[1];
-			if (seen.def && seen.defId) defs[seen.defId] = seen.def;
-		}
-		if (!params.external && Object.keys(defs).length > 0) if (this.target === "draft-2020-12") result.$defs = defs;
-		else result.definitions = defs;
-		try {
-			return JSON.parse(JSON.stringify(result));
-		} catch (_err) {
-			throw new Error("Error converting schema to JSON.");
-		}
-	}
-};
-function toJSONSchema(input, _params) {
-	if (input instanceof $ZodRegistry) {
-		const gen$1 = new JSONSchemaGenerator(_params);
-		const defs = {};
-		for (const entry of input._idmap.entries()) {
-			const [_, schema] = entry;
-			gen$1.process(schema);
-		}
-		const schemas = {};
-		const external = {
-			registry: input,
-			uri: _params?.uri || ((id) => id),
-			defs
-		};
-		for (const entry of input._idmap.entries()) {
-			const [key, schema] = entry;
-			schemas[key] = gen$1.emit(schema, {
-				..._params,
-				external
-			});
-		}
-		if (Object.keys(defs).length > 0) {
-			const defsSegment = gen$1.target === "draft-2020-12" ? "$defs" : "definitions";
-			schemas.__shared = { [defsSegment]: defs };
-		}
-		return { schemas };
-	}
-	const gen = new JSONSchemaGenerator(_params);
-	gen.process(input);
-	return gen.emit(input, _params);
-}
-function isTransforming(_schema, _ctx) {
-	const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
-	if (ctx.seen.has(_schema)) return false;
-	ctx.seen.add(_schema);
-	const schema = _schema;
-	const def = schema._zod.def;
-	switch (def.type) {
-		case "string":
-		case "number":
-		case "bigint":
-		case "boolean":
-		case "date":
-		case "symbol":
-		case "undefined":
-		case "null":
-		case "any":
-		case "unknown":
-		case "never":
-		case "void":
-		case "literal":
-		case "enum":
-		case "nan":
-		case "file":
-		case "template_literal": return false;
-		case "array": return isTransforming(def.element, ctx);
-		case "object": {
-			for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
-			return false;
-		}
-		case "union": {
-			for (const option of def.options) if (isTransforming(option, ctx)) return true;
-			return false;
-		}
-		case "intersection": return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
-		case "tuple": {
-			for (const item of def.items) if (isTransforming(item, ctx)) return true;
-			if (def.rest && isTransforming(def.rest, ctx)) return true;
-			return false;
-		}
-		case "record": return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-		case "map": return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
-		case "set": return isTransforming(def.valueType, ctx);
-		case "promise":
-		case "optional":
-		case "nonoptional":
-		case "nullable":
-		case "readonly": return isTransforming(def.innerType, ctx);
-		case "lazy": return isTransforming(def.getter(), ctx);
-		case "default": return isTransforming(def.innerType, ctx);
-		case "prefault": return isTransforming(def.innerType, ctx);
-		case "custom": return false;
-		case "transform": return true;
-		case "pipe": return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
-		case "success": return false;
-		case "catch": return false;
-		default:
-	}
-	throw new Error(`Unknown schema type: ${def.type}`);
-}
-
-//#endregion
-export { toJSONSchema };

package/dist/effect-WSjEuzC9-DHMVzzyB.js

@@ -1,10 +0,0 @@
-import { tryImport } from "./index-CISmcbXk-CW1Gj6Ab.js";
-
-//#region node_modules/xsschema/dist/effect-WSjEuzC9.js
-const getToJsonSchemaFn = async () => {
-	const { JSONSchema } = await tryImport(import("effect"), "effect");
-	return (schema) => JSONSchema.make(schema);
-};
-
-//#endregion
-export { getToJsonSchemaFn };

package/dist/sury-DmrZ3_Oj-Cpjsc2Lm.js

@@ -1,10 +0,0 @@
-import { tryImport } from "./index-CISmcbXk-CW1Gj6Ab.js";
-
-//#region node_modules/xsschema/dist/sury-DmrZ3_Oj.js
-const getToJsonSchemaFn = async () => {
-	const { toJSONSchema } = await tryImport(import("sury"), "sury");
-	return (schema) => toJSONSchema(schema);
-};
-
-//#endregion
-export { getToJsonSchemaFn };