@envguard/node
Version:
EnvGuard Node.js runtime - Drop-in dotenv replacement with OS keychain
1,548 lines (1,540 loc) • 509 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// ../core/dist/index.js
var import_keyring = require("@napi-rs/keyring");
var console2 = __toESM(require("console"), 1);
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/external.js
var external_exports = {};
__export(external_exports, {
$brand: () => $brand,
$input: () => $input,
$output: () => $output,
NEVER: () => NEVER,
TimePrecision: () => TimePrecision,
ZodAny: () => ZodAny,
ZodArray: () => ZodArray,
ZodBase64: () => ZodBase64,
ZodBase64URL: () => ZodBase64URL,
ZodBigInt: () => ZodBigInt,
ZodBigIntFormat: () => ZodBigIntFormat,
ZodBoolean: () => ZodBoolean,
ZodCIDRv4: () => ZodCIDRv4,
ZodCIDRv6: () => ZodCIDRv6,
ZodCUID: () => ZodCUID,
ZodCUID2: () => ZodCUID2,
ZodCatch: () => ZodCatch,
ZodCodec: () => ZodCodec,
ZodCustom: () => ZodCustom,
ZodCustomStringFormat: () => ZodCustomStringFormat,
ZodDate: () => ZodDate,
ZodDefault: () => ZodDefault,
ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
ZodE164: () => ZodE164,
ZodEmail: () => ZodEmail,
ZodEmoji: () => ZodEmoji,
ZodEnum: () => ZodEnum,
ZodError: () => ZodError,
ZodFile: () => ZodFile,
ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
ZodFunction: () => ZodFunction,
ZodGUID: () => ZodGUID,
ZodIPv4: () => ZodIPv4,
ZodIPv6: () => ZodIPv6,
ZodISODate: () => ZodISODate,
ZodISODateTime: () => ZodISODateTime,
ZodISODuration: () => ZodISODuration,
ZodISOTime: () => ZodISOTime,
ZodIntersection: () => ZodIntersection,
ZodIssueCode: () => ZodIssueCode,
ZodJWT: () => ZodJWT,
ZodKSUID: () => ZodKSUID,
ZodLazy: () => ZodLazy,
ZodLiteral: () => ZodLiteral,
ZodMap: () => ZodMap,
ZodNaN: () => ZodNaN,
ZodNanoID: () => ZodNanoID,
ZodNever: () => ZodNever,
ZodNonOptional: () => ZodNonOptional,
ZodNull: () => ZodNull,
ZodNullable: () => ZodNullable,
ZodNumber: () => ZodNumber,
ZodNumberFormat: () => ZodNumberFormat,
ZodObject: () => ZodObject,
ZodOptional: () => ZodOptional,
ZodPipe: () => ZodPipe,
ZodPrefault: () => ZodPrefault,
ZodPromise: () => ZodPromise,
ZodReadonly: () => ZodReadonly,
ZodRealError: () => ZodRealError,
ZodRecord: () => ZodRecord,
ZodSet: () => ZodSet,
ZodString: () => ZodString,
ZodStringFormat: () => ZodStringFormat,
ZodSuccess: () => ZodSuccess,
ZodSymbol: () => ZodSymbol,
ZodTemplateLiteral: () => ZodTemplateLiteral,
ZodTransform: () => ZodTransform,
ZodTuple: () => ZodTuple,
ZodType: () => ZodType,
ZodULID: () => ZodULID,
ZodURL: () => ZodURL,
ZodUUID: () => ZodUUID,
ZodUndefined: () => ZodUndefined,
ZodUnion: () => ZodUnion,
ZodUnknown: () => ZodUnknown,
ZodVoid: () => ZodVoid,
ZodXID: () => ZodXID,
_ZodString: () => _ZodString,
_default: () => _default2,
_function: () => _function,
any: () => any,
array: () => array,
base64: () => base642,
base64url: () => base64url2,
bigint: () => bigint2,
boolean: () => boolean2,
catch: () => _catch2,
check: () => check,
cidrv4: () => cidrv42,
cidrv6: () => cidrv62,
clone: () => clone,
codec: () => codec,
coerce: () => coerce_exports,
config: () => config,
core: () => core_exports2,
cuid: () => cuid3,
cuid2: () => cuid22,
custom: () => custom,
date: () => date3,
decode: () => decode2,
decodeAsync: () => decodeAsync2,
discriminatedUnion: () => discriminatedUnion,
e164: () => e1642,
email: () => email2,
emoji: () => emoji2,
encode: () => encode2,
encodeAsync: () => encodeAsync2,
endsWith: () => _endsWith,
enum: () => _enum2,
file: () => file,
flattenError: () => flattenError,
float32: () => float32,
float64: () => float64,
formatError: () => formatError,
function: () => _function,
getErrorMap: () => getErrorMap,
globalRegistry: () => globalRegistry,
gt: () => _gt,
gte: () => _gte,
guid: () => guid2,
hash: () => hash,
hex: () => hex2,
hostname: () => hostname2,
httpUrl: () => httpUrl,
includes: () => _includes,
instanceof: () => _instanceof,
int: () => int,
int32: () => int32,
int64: () => int64,
intersection: () => intersection,
ipv4: () => ipv42,
ipv6: () => ipv62,
iso: () => iso_exports,
json: () => json,
jwt: () => jwt,
keyof: () => keyof,
ksuid: () => ksuid2,
lazy: () => lazy,
length: () => _length,
literal: () => literal,
locales: () => locales_exports,
looseObject: () => looseObject,
lowercase: () => _lowercase,
lt: () => _lt,
lte: () => _lte,
map: () => map,
maxLength: () => _maxLength,
maxSize: () => _maxSize,
mime: () => _mime,
minLength: () => _minLength,
minSize: () => _minSize,
multipleOf: () => _multipleOf,
nan: () => nan,
nanoid: () => nanoid2,
nativeEnum: () => nativeEnum,
negative: () => _negative,
never: () => never,
nonnegative: () => _nonnegative,
nonoptional: () => nonoptional,
nonpositive: () => _nonpositive,
normalize: () => _normalize,
null: () => _null3,
nullable: () => nullable,
nullish: () => nullish2,
number: () => number2,
object: () => object,
optional: () => optional,
overwrite: () => _overwrite,
parse: () => parse2,
parseAsync: () => parseAsync2,
partialRecord: () => partialRecord,
pipe: () => pipe,
positive: () => _positive,
prefault: () => prefault,
preprocess: () => preprocess,
prettifyError: () => prettifyError,
promise: () => promise,
property: () => _property,
readonly: () => readonly,
record: () => record,
refine: () => refine,
regex: () => _regex,
regexes: () => regexes_exports,
registry: () => registry,
safeDecode: () => safeDecode2,
safeDecodeAsync: () => safeDecodeAsync2,
safeEncode: () => safeEncode2,
safeEncodeAsync: () => safeEncodeAsync2,
safeParse: () => safeParse2,
safeParseAsync: () => safeParseAsync2,
set: () => set,
setErrorMap: () => setErrorMap,
size: () => _size,
startsWith: () => _startsWith,
strictObject: () => strictObject,
string: () => string2,
stringFormat: () => stringFormat,
stringbool: () => stringbool,
success: () => success,
superRefine: () => superRefine,
symbol: () => symbol,
templateLiteral: () => templateLiteral,
toJSONSchema: () => toJSONSchema,
toLowerCase: () => _toLowerCase,
toUpperCase: () => _toUpperCase,
transform: () => transform,
treeifyError: () => treeifyError,
trim: () => _trim,
tuple: () => tuple,
uint32: () => uint32,
uint64: () => uint64,
ulid: () => ulid2,
undefined: () => _undefined3,
union: () => union,
unknown: () => unknown,
uppercase: () => _uppercase,
url: () => url,
util: () => util_exports,
uuid: () => uuid2,
uuidv4: () => uuidv4,
uuidv6: () => uuidv6,
uuidv7: () => uuidv7,
void: () => _void2,
xid: () => xid2
});
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/core/index.js
var core_exports2 = {};
__export(core_exports2, {
$ZodAny: () => $ZodAny,
$ZodArray: () => $ZodArray,
$ZodAsyncError: () => $ZodAsyncError,
$ZodBase64: () => $ZodBase64,
$ZodBase64URL: () => $ZodBase64URL,
$ZodBigInt: () => $ZodBigInt,
$ZodBigIntFormat: () => $ZodBigIntFormat,
$ZodBoolean: () => $ZodBoolean,
$ZodCIDRv4: () => $ZodCIDRv4,
$ZodCIDRv6: () => $ZodCIDRv6,
$ZodCUID: () => $ZodCUID,
$ZodCUID2: () => $ZodCUID2,
$ZodCatch: () => $ZodCatch,
$ZodCheck: () => $ZodCheck,
$ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
$ZodCheckEndsWith: () => $ZodCheckEndsWith,
$ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
$ZodCheckIncludes: () => $ZodCheckIncludes,
$ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
$ZodCheckLessThan: () => $ZodCheckLessThan,
$ZodCheckLowerCase: () => $ZodCheckLowerCase,
$ZodCheckMaxLength: () => $ZodCheckMaxLength,
$ZodCheckMaxSize: () => $ZodCheckMaxSize,
$ZodCheckMimeType: () => $ZodCheckMimeType,
$ZodCheckMinLength: () => $ZodCheckMinLength,
$ZodCheckMinSize: () => $ZodCheckMinSize,
$ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
$ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
$ZodCheckOverwrite: () => $ZodCheckOverwrite,
$ZodCheckProperty: () => $ZodCheckProperty,
$ZodCheckRegex: () => $ZodCheckRegex,
$ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
$ZodCheckStartsWith: () => $ZodCheckStartsWith,
$ZodCheckStringFormat: () => $ZodCheckStringFormat,
$ZodCheckUpperCase: () => $ZodCheckUpperCase,
$ZodCodec: () => $ZodCodec,
$ZodCustom: () => $ZodCustom,
$ZodCustomStringFormat: () => $ZodCustomStringFormat,
$ZodDate: () => $ZodDate,
$ZodDefault: () => $ZodDefault,
$ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
$ZodE164: () => $ZodE164,
$ZodEmail: () => $ZodEmail,
$ZodEmoji: () => $ZodEmoji,
$ZodEncodeError: () => $ZodEncodeError,
$ZodEnum: () => $ZodEnum,
$ZodError: () => $ZodError,
$ZodFile: () => $ZodFile,
$ZodFunction: () => $ZodFunction,
$ZodGUID: () => $ZodGUID,
$ZodIPv4: () => $ZodIPv4,
$ZodIPv6: () => $ZodIPv6,
$ZodISODate: () => $ZodISODate,
$ZodISODateTime: () => $ZodISODateTime,
$ZodISODuration: () => $ZodISODuration,
$ZodISOTime: () => $ZodISOTime,
$ZodIntersection: () => $ZodIntersection,
$ZodJWT: () => $ZodJWT,
$ZodKSUID: () => $ZodKSUID,
$ZodLazy: () => $ZodLazy,
$ZodLiteral: () => $ZodLiteral,
$ZodMap: () => $ZodMap,
$ZodNaN: () => $ZodNaN,
$ZodNanoID: () => $ZodNanoID,
$ZodNever: () => $ZodNever,
$ZodNonOptional: () => $ZodNonOptional,
$ZodNull: () => $ZodNull,
$ZodNullable: () => $ZodNullable,
$ZodNumber: () => $ZodNumber,
$ZodNumberFormat: () => $ZodNumberFormat,
$ZodObject: () => $ZodObject,
$ZodObjectJIT: () => $ZodObjectJIT,
$ZodOptional: () => $ZodOptional,
$ZodPipe: () => $ZodPipe,
$ZodPrefault: () => $ZodPrefault,
$ZodPromise: () => $ZodPromise,
$ZodReadonly: () => $ZodReadonly,
$ZodRealError: () => $ZodRealError,
$ZodRecord: () => $ZodRecord,
$ZodRegistry: () => $ZodRegistry,
$ZodSet: () => $ZodSet,
$ZodString: () => $ZodString,
$ZodStringFormat: () => $ZodStringFormat,
$ZodSuccess: () => $ZodSuccess,
$ZodSymbol: () => $ZodSymbol,
$ZodTemplateLiteral: () => $ZodTemplateLiteral,
$ZodTransform: () => $ZodTransform,
$ZodTuple: () => $ZodTuple,
$ZodType: () => $ZodType,
$ZodULID: () => $ZodULID,
$ZodURL: () => $ZodURL,
$ZodUUID: () => $ZodUUID,
$ZodUndefined: () => $ZodUndefined,
$ZodUnion: () => $ZodUnion,
$ZodUnknown: () => $ZodUnknown,
$ZodVoid: () => $ZodVoid,
$ZodXID: () => $ZodXID,
$brand: () => $brand,
$constructor: () => $constructor,
$input: () => $input,
$output: () => $output,
Doc: () => Doc,
JSONSchema: () => json_schema_exports,
JSONSchemaGenerator: () => JSONSchemaGenerator,
NEVER: () => NEVER,
TimePrecision: () => TimePrecision,
_any: () => _any,
_array: () => _array,
_base64: () => _base64,
_base64url: () => _base64url,
_bigint: () => _bigint,
_boolean: () => _boolean,
_catch: () => _catch,
_check: () => _check,
_cidrv4: () => _cidrv4,
_cidrv6: () => _cidrv6,
_coercedBigint: () => _coercedBigint,
_coercedBoolean: () => _coercedBoolean,
_coercedDate: () => _coercedDate,
_coercedNumber: () => _coercedNumber,
_coercedString: () => _coercedString,
_cuid: () => _cuid,
_cuid2: () => _cuid2,
_custom: () => _custom,
_date: () => _date,
_decode: () => _decode,
_decodeAsync: () => _decodeAsync,
_default: () => _default,
_discriminatedUnion: () => _discriminatedUnion,
_e164: () => _e164,
_email: () => _email,
_emoji: () => _emoji2,
_encode: () => _encode,
_encodeAsync: () => _encodeAsync,
_endsWith: () => _endsWith,
_enum: () => _enum,
_file: () => _file,
_float32: () => _float32,
_float64: () => _float64,
_gt: () => _gt,
_gte: () => _gte,
_guid: () => _guid,
_includes: () => _includes,
_int: () => _int,
_int32: () => _int32,
_int64: () => _int64,
_intersection: () => _intersection,
_ipv4: () => _ipv4,
_ipv6: () => _ipv6,
_isoDate: () => _isoDate,
_isoDateTime: () => _isoDateTime,
_isoDuration: () => _isoDuration,
_isoTime: () => _isoTime,
_jwt: () => _jwt,
_ksuid: () => _ksuid,
_lazy: () => _lazy,
_length: () => _length,
_literal: () => _literal,
_lowercase: () => _lowercase,
_lt: () => _lt,
_lte: () => _lte,
_map: () => _map,
_max: () => _lte,
_maxLength: () => _maxLength,
_maxSize: () => _maxSize,
_mime: () => _mime,
_min: () => _gte,
_minLength: () => _minLength,
_minSize: () => _minSize,
_multipleOf: () => _multipleOf,
_nan: () => _nan,
_nanoid: () => _nanoid,
_nativeEnum: () => _nativeEnum,
_negative: () => _negative,
_never: () => _never,
_nonnegative: () => _nonnegative,
_nonoptional: () => _nonoptional,
_nonpositive: () => _nonpositive,
_normalize: () => _normalize,
_null: () => _null2,
_nullable: () => _nullable,
_number: () => _number,
_optional: () => _optional,
_overwrite: () => _overwrite,
_parse: () => _parse,
_parseAsync: () => _parseAsync,
_pipe: () => _pipe,
_positive: () => _positive,
_promise: () => _promise,
_property: () => _property,
_readonly: () => _readonly,
_record: () => _record,
_refine: () => _refine,
_regex: () => _regex,
_safeDecode: () => _safeDecode,
_safeDecodeAsync: () => _safeDecodeAsync,
_safeEncode: () => _safeEncode,
_safeEncodeAsync: () => _safeEncodeAsync,
_safeParse: () => _safeParse,
_safeParseAsync: () => _safeParseAsync,
_set: () => _set,
_size: () => _size,
_startsWith: () => _startsWith,
_string: () => _string,
_stringFormat: () => _stringFormat,
_stringbool: () => _stringbool,
_success: () => _success,
_superRefine: () => _superRefine,
_symbol: () => _symbol,
_templateLiteral: () => _templateLiteral,
_toLowerCase: () => _toLowerCase,
_toUpperCase: () => _toUpperCase,
_transform: () => _transform,
_trim: () => _trim,
_tuple: () => _tuple,
_uint32: () => _uint32,
_uint64: () => _uint64,
_ulid: () => _ulid,
_undefined: () => _undefined2,
_union: () => _union,
_unknown: () => _unknown,
_uppercase: () => _uppercase,
_url: () => _url,
_uuid: () => _uuid,
_uuidv4: () => _uuidv4,
_uuidv6: () => _uuidv6,
_uuidv7: () => _uuidv7,
_void: () => _void,
_xid: () => _xid,
clone: () => clone,
config: () => config,
decode: () => decode,
decodeAsync: () => decodeAsync,
encode: () => encode,
encodeAsync: () => encodeAsync,
flattenError: () => flattenError,
formatError: () => formatError,
globalConfig: () => globalConfig,
globalRegistry: () => globalRegistry,
isValidBase64: () => isValidBase64,
isValidBase64URL: () => isValidBase64URL,
isValidJWT: () => isValidJWT,
locales: () => locales_exports,
parse: () => parse,
parseAsync: () => parseAsync,
prettifyError: () => prettifyError,
regexes: () => regexes_exports,
registry: () => registry,
safeDecode: () => safeDecode,
safeDecodeAsync: () => safeDecodeAsync,
safeEncode: () => safeEncode,
safeEncodeAsync: () => safeEncodeAsync,
safeParse: () => safeParse,
safeParseAsync: () => safeParseAsync,
toDotPath: () => toDotPath,
toJSONSchema: () => toJSONSchema,
treeifyError: () => treeifyError,
util: () => util_exports,
version: () => version
});
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/core/core.js
var NEVER = Object.freeze({
status: "aborted"
});
// @__NO_SIDE_EFFECTS__
function $constructor(name, initializer3, params) {
function init(inst, def) {
var _a;
Object.defineProperty(inst, "_zod", {
value: inst._zod ?? {},
enumerable: false
});
(_a = inst._zod).traits ?? (_a.traits = /* @__PURE__ */ new Set());
inst._zod.traits.add(name);
initializer3(inst, def);
for (const k in _.prototype) {
if (!(k in inst))
Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
}
inst._zod.constr = _;
inst._zod.def = def;
}
const Parent = params?.Parent ?? Object;
class Definition extends Parent {
}
Object.defineProperty(Definition, "name", { value: name });
function _(def) {
var _a;
const inst = params?.Parent ? new Definition() : this;
init(inst, def);
(_a = inst._zod).deferred ?? (_a.deferred = []);
for (const fn of inst._zod.deferred) {
fn();
}
return inst;
}
Object.defineProperty(_, "init", { value: init });
Object.defineProperty(_, Symbol.hasInstance, {
value: (inst) => {
if (params?.Parent && inst instanceof params.Parent)
return true;
return inst?._zod?.traits?.has(name);
}
});
Object.defineProperty(_, "name", { value: name });
return _;
}
var $brand = Symbol("zod_brand");
var $ZodAsyncError = class extends Error {
constructor() {
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
}
};
var $ZodEncodeError = class extends Error {
constructor(name) {
super(`Encountered unidirectional transform during encode: ${name}`);
this.name = "ZodEncodeError";
}
};
var globalConfig = {};
function config(newConfig) {
if (newConfig)
Object.assign(globalConfig, newConfig);
return globalConfig;
}
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
Class: () => Class,
NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
aborted: () => aborted,
allowsEval: () => allowsEval,
assert: () => assert,
assertEqual: () => assertEqual,
assertIs: () => assertIs,
assertNever: () => assertNever,
assertNotEqual: () => assertNotEqual,
assignProp: () => assignProp,
base64ToUint8Array: () => base64ToUint8Array,
base64urlToUint8Array: () => base64urlToUint8Array,
cached: () => cached,
captureStackTrace: () => captureStackTrace,
cleanEnum: () => cleanEnum,
cleanRegex: () => cleanRegex,
clone: () => clone,
cloneDef: () => cloneDef,
createTransparentProxy: () => createTransparentProxy,
defineLazy: () => defineLazy,
esc: () => esc,
escapeRegex: () => escapeRegex,
extend: () => extend,
finalizeIssue: () => finalizeIssue,
floatSafeRemainder: () => floatSafeRemainder,
getElementAtPath: () => getElementAtPath,
getEnumValues: () => getEnumValues,
getLengthableOrigin: () => getLengthableOrigin,
getParsedType: () => getParsedType,
getSizableOrigin: () => getSizableOrigin,
hexToUint8Array: () => hexToUint8Array,
isObject: () => isObject,
isPlainObject: () => isPlainObject,
issue: () => issue,
joinValues: () => joinValues,
jsonStringifyReplacer: () => jsonStringifyReplacer,
merge: () => merge,
mergeDefs: () => mergeDefs,
normalizeParams: () => normalizeParams,
nullish: () => nullish,
numKeys: () => numKeys,
objectClone: () => objectClone,
omit: () => omit,
optionalKeys: () => optionalKeys,
partial: () => partial,
pick: () => pick,
prefixIssues: () => prefixIssues,
primitiveTypes: () => primitiveTypes,
promiseAllObject: () => promiseAllObject,
propertyKeyTypes: () => propertyKeyTypes,
randomString: () => randomString,
required: () => required,
safeExtend: () => safeExtend,
shallowClone: () => shallowClone,
stringifyPrimitive: () => stringifyPrimitive,
uint8ArrayToBase64: () => uint8ArrayToBase64,
uint8ArrayToBase64url: () => uint8ArrayToBase64url,
uint8ArrayToHex: () => uint8ArrayToHex,
unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
return val;
}
function assertNotEqual(val) {
return val;
}
function assertIs(_arg) {
}
function assertNever(_x) {
throw new Error();
}
function assert(_) {
}
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 joinValues(array2, separator = "|") {
return array2.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
if (typeof value === "bigint")
return value.toString();
return value;
}
function cached(getter) {
const set2 = false;
return {
get value() {
if (!set2) {
const value = getter();
Object.defineProperty(this, "value", { value });
return value;
}
throw new Error("cached value already set");
}
};
}
function nullish(input) {
return input === null || input === void 0;
}
function cleanRegex(source) {
const start = source.startsWith("^") ? 1 : 0;
const end = source.endsWith("$") ? source.length - 1 : source.length;
return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
const valDecCount = (val.toString().split(".")[1] || "").length;
const stepString = step.toString();
let stepDecCount = (stepString.split(".")[1] || "").length;
if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
const match = stepString.match(/\d?e-(\d?)/);
if (match?.[1]) {
stepDecCount = Number.parseInt(match[1]);
}
}
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
return valInt % stepInt / 10 ** decCount;
}
var EVALUATING = Symbol("evaluating");
function defineLazy(object2, key, getter) {
let value = void 0;
Object.defineProperty(object2, key, {
get() {
if (value === EVALUATING) {
return void 0;
}
if (value === void 0) {
value = EVALUATING;
value = getter();
}
return value;
},
set(v) {
Object.defineProperty(object2, key, {
value: v
// configurable: true,
});
},
configurable: true
});
}
function objectClone(obj) {
return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
}
function assignProp(target, prop, value) {
Object.defineProperty(target, prop, {
value,
writable: true,
enumerable: true,
configurable: true
});
}
function mergeDefs(...defs) {
const mergedDescriptors = {};
for (const def of defs) {
const descriptors = Object.getOwnPropertyDescriptors(def);
Object.assign(mergedDescriptors, descriptors);
}
return Object.defineProperties({}, mergedDescriptors);
}
function cloneDef(schema) {
return mergeDefs(schema._zod.def);
}
function getElementAtPath(obj, path) {
if (!path)
return obj;
return path.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
const keys = Object.keys(promisesObj);
const promises = keys.map((key) => promisesObj[key]);
return Promise.all(promises).then((results) => {
const resolvedObj = {};
for (let i = 0; i < keys.length; i++) {
resolvedObj[keys[i]] = results[i];
}
return resolvedObj;
});
}
function randomString(length = 10) {
const chars = "abcdefghijklmnopqrstuvwxyz";
let str = "";
for (let i = 0; i < length; i++) {
str += chars[Math.floor(Math.random() * chars.length)];
}
return str;
}
function esc(str) {
return JSON.stringify(str);
}
var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
};
function isObject(data) {
return typeof data === "object" && data !== null && !Array.isArray(data);
}
var allowsEval = cached(() => {
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
return false;
}
try {
const F = Function;
new F("");
return true;
} catch (_) {
return false;
}
});
function isPlainObject(o) {
if (isObject(o) === false)
return false;
const ctor = o.constructor;
if (ctor === void 0)
return true;
const prot = ctor.prototype;
if (isObject(prot) === false)
return false;
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
return false;
}
return true;
}
function shallowClone(o) {
if (isPlainObject(o))
return { ...o };
if (Array.isArray(o))
return [...o];
return o;
}
function numKeys(data) {
let keyCount = 0;
for (const key in data) {
if (Object.prototype.hasOwnProperty.call(data, key)) {
keyCount++;
}
}
return keyCount;
}
var getParsedType = (data) => {
const t = typeof data;
switch (t) {
case "undefined":
return "undefined";
case "string":
return "string";
case "number":
return Number.isNaN(data) ? "nan" : "number";
case "boolean":
return "boolean";
case "function":
return "function";
case "bigint":
return "bigint";
case "symbol":
return "symbol";
case "object":
if (Array.isArray(data)) {
return "array";
}
if (data === null) {
return "null";
}
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
return "promise";
}
if (typeof Map !== "undefined" && data instanceof Map) {
return "map";
}
if (typeof Set !== "undefined" && data instanceof Set) {
return "set";
}
if (typeof Date !== "undefined" && data instanceof Date) {
return "date";
}
if (typeof File !== "undefined" && data instanceof File) {
return "file";
}
return "object";
default:
throw new Error(`Unknown data type: ${t}`);
}
};
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
function escapeRegex(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
const cl = new inst._zod.constr(def ?? inst._zod.def);
if (!def || params?.parent)
cl._zod.parent = inst;
return cl;
}
function normalizeParams(_params) {
const params = _params;
if (!params)
return {};
if (typeof params === "string")
return { error: () => params };
if (params?.message !== void 0) {
if (params?.error !== void 0)
throw new Error("Cannot specify both `message` and `error` params");
params.error = params.message;
}
delete params.message;
if (typeof params.error === "string")
return { ...params, error: () => params.error };
return params;
}
function createTransparentProxy(getter) {
let target;
return new Proxy({}, {
get(_, prop, receiver) {
target ?? (target = getter());
return Reflect.get(target, prop, receiver);
},
set(_, prop, value, receiver) {
target ?? (target = getter());
return Reflect.set(target, prop, value, receiver);
},
has(_, prop) {
target ?? (target = getter());
return Reflect.has(target, prop);
},
deleteProperty(_, prop) {
target ?? (target = getter());
return Reflect.deleteProperty(target, prop);
},
ownKeys(_) {
target ?? (target = getter());
return Reflect.ownKeys(target);
},
getOwnPropertyDescriptor(_, prop) {
target ?? (target = getter());
return Reflect.getOwnPropertyDescriptor(target, prop);
},
defineProperty(_, prop, descriptor) {
target ?? (target = getter());
return Reflect.defineProperty(target, prop, descriptor);
}
});
}
function stringifyPrimitive(value) {
if (typeof value === "bigint")
return value.toString() + "n";
if (typeof value === "string")
return `"${value}"`;
return `${value}`;
}
function optionalKeys(shape) {
return Object.keys(shape).filter((k) => {
return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
});
}
var 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]
};
var BIGINT_FORMAT_RANGES = {
int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
const currDef = schema._zod.def;
const def = mergeDefs(schema._zod.def, {
get shape() {
const newShape = {};
for (const key in mask) {
if (!(key in currDef.shape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
newShape[key] = currDef.shape[key];
}
assignProp(this, "shape", newShape);
return newShape;
},
checks: []
});
return clone(schema, def);
}
function omit(schema, mask) {
const currDef = schema._zod.def;
const def = mergeDefs(schema._zod.def, {
get shape() {
const newShape = { ...schema._zod.def.shape };
for (const key in mask) {
if (!(key in currDef.shape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
delete newShape[key];
}
assignProp(this, "shape", newShape);
return newShape;
},
checks: []
});
return clone(schema, def);
}
function extend(schema, shape) {
if (!isPlainObject(shape)) {
throw new Error("Invalid input to extend: expected a plain object");
}
const checks = schema._zod.def.checks;
const hasChecks = checks && checks.length > 0;
if (hasChecks) {
throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
}
const def = mergeDefs(schema._zod.def, {
get shape() {
const _shape = { ...schema._zod.def.shape, ...shape };
assignProp(this, "shape", _shape);
return _shape;
},
checks: []
});
return clone(schema, def);
}
function safeExtend(schema, shape) {
if (!isPlainObject(shape)) {
throw new Error("Invalid input to safeExtend: expected a plain object");
}
const def = {
...schema._zod.def,
get shape() {
const _shape = { ...schema._zod.def.shape, ...shape };
assignProp(this, "shape", _shape);
return _shape;
},
checks: schema._zod.def.checks
};
return clone(schema, def);
}
function merge(a, b) {
const def = mergeDefs(a._zod.def, {
get shape() {
const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
assignProp(this, "shape", _shape);
return _shape;
},
get catchall() {
return b._zod.def.catchall;
},
checks: []
// delete existing checks
});
return clone(a, def);
}
function partial(Class2, schema, mask) {
const def = mergeDefs(schema._zod.def, {
get shape() {
const oldShape = schema._zod.def.shape;
const shape = { ...oldShape };
if (mask) {
for (const key in mask) {
if (!(key in oldShape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
shape[key] = Class2 ? new Class2({
type: "optional",
innerType: oldShape[key]
}) : oldShape[key];
}
} else {
for (const key in oldShape) {
shape[key] = Class2 ? new Class2({
type: "optional",
innerType: oldShape[key]
}) : oldShape[key];
}
}
assignProp(this, "shape", shape);
return shape;
},
checks: []
});
return clone(schema, def);
}
function required(Class2, schema, mask) {
const def = mergeDefs(schema._zod.def, {
get shape() {
const oldShape = schema._zod.def.shape;
const shape = { ...oldShape };
if (mask) {
for (const key in mask) {
if (!(key in shape)) {
throw new Error(`Unrecognized key: "${key}"`);
}
if (!mask[key])
continue;
shape[key] = new Class2({
type: "nonoptional",
innerType: oldShape[key]
});
}
} else {
for (const key in oldShape) {
shape[key] = new Class2({
type: "nonoptional",
innerType: oldShape[key]
});
}
}
assignProp(this, "shape", shape);
return shape;
},
checks: []
});
return clone(schema, def);
}
function aborted(x, startIndex = 0) {
if (x.aborted === true)
return true;
for (let i = startIndex; i < x.issues.length; i++) {
if (x.issues[i]?.continue !== true) {
return true;
}
}
return false;
}
function prefixIssues(path, issues) {
return issues.map((iss) => {
var _a;
(_a = iss).path ?? (_a.path = []);
iss.path.unshift(path);
return iss;
});
}
function unwrapMessage(message) {
return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config2) {
const full = { ...iss, path: iss.path ?? [] };
if (!iss.message) {
const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
full.message = message;
}
delete full.inst;
delete full.continue;
if (!ctx?.reportInput) {
delete full.input;
}
return full;
}
function getSizableOrigin(input) {
if (input instanceof Set)
return "set";
if (input instanceof Map)
return "map";
if (input instanceof File)
return "file";
return "unknown";
}
function getLengthableOrigin(input) {
if (Array.isArray(input))
return "array";
if (typeof input === "string")
return "string";
return "unknown";
}
function issue(...args) {
const [iss, input, inst] = args;
if (typeof iss === "string") {
return {
message: iss,
code: "custom",
input,
inst
};
}
return { ...iss };
}
function cleanEnum(obj) {
return Object.entries(obj).filter(([k, _]) => {
return Number.isNaN(Number.parseInt(k, 10));
}).map((el) => el[1]);
}
function base64ToUint8Array(base643) {
const binaryString = atob(base643);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
return bytes;
}
function uint8ArrayToBase64(bytes) {
let binaryString = "";
for (let i = 0; i < bytes.length; i++) {
binaryString += String.fromCharCode(bytes[i]);
}
return btoa(binaryString);
}
function base64urlToUint8Array(base64url3) {
const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/");
const padding = "=".repeat((4 - base643.length % 4) % 4);
return base64ToUint8Array(base643 + padding);
}
function uint8ArrayToBase64url(bytes) {
return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array(hex3) {
const cleanHex = hex3.replace(/^0x/, "");
if (cleanHex.length % 2 !== 0) {
throw new Error("Invalid hex string length");
}
const bytes = new Uint8Array(cleanHex.length / 2);
for (let i = 0; i < cleanHex.length; i += 2) {
bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
}
return bytes;
}
function uint8ArrayToHex(bytes) {
return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
var Class = class {
constructor(..._args) {
}
};
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/core/errors.js
var initializer = (inst, def) => {
inst.name = "$ZodError";
Object.defineProperty(inst, "_zod", {
value: inst._zod,
enumerable: false
});
Object.defineProperty(inst, "issues", {
value: def,
enumerable: false
});
inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
Object.defineProperty(inst, "toString", {
value: () => inst.message,
enumerable: false
});
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
function flattenError(error47, mapper = (issue2) => issue2.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of error47.issues) {
if (sub.path.length > 0) {
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
fieldErrors[sub.path[0]].push(mapper(sub));
} else {
formErrors.push(mapper(sub));
}
}
return { formErrors, fieldErrors };
}
function formatError(error47, mapper = (issue2) => issue2.message) {
const fieldErrors = { _errors: [] };
const processError = (error48) => {
for (const issue2 of error48.issues) {
if (issue2.code === "invalid_union" && issue2.errors.length) {
issue2.errors.map((issues) => processError({ issues }));
} else if (issue2.code === "invalid_key") {
processError({ issues: issue2.issues });
} else if (issue2.code === "invalid_element") {
processError({ issues: issue2.issues });
} else if (issue2.path.length === 0) {
fieldErrors._errors.push(mapper(issue2));
} else {
let curr = fieldErrors;
let i = 0;
while (i < issue2.path.length) {
const el = issue2.path[i];
const terminal = i === issue2.path.length - 1;
if (!terminal) {
curr[el] = curr[el] || { _errors: [] };
} else {
curr[el] = curr[el] || { _errors: [] };
curr[el]._errors.push(mapper(issue2));
}
curr = curr[el];
i++;
}
}
}
};
processError(error47);
return fieldErrors;
}
function treeifyError(error47, mapper = (issue2) => issue2.message) {
const result = { errors: [] };
const processError = (error48, path = []) => {
var _a, _b;
for (const issue2 of error48.issues) {
if (issue2.code === "invalid_union" && issue2.errors.length) {
issue2.errors.map((issues) => processError({ issues }, issue2.path));
} else if (issue2.code === "invalid_key") {
processError({ issues: issue2.issues }, issue2.path);
} else if (issue2.code === "invalid_element") {
processError({ issues: issue2.issues }, issue2.path);
} else {
const fullpath = [...path, ...issue2.path];
if (fullpath.length === 0) {
result.errors.push(mapper(issue2));
continue;
}
let curr = result;
let i = 0;
while (i < fullpath.length) {
const el = fullpath[i];
const terminal = i === fullpath.length - 1;
if (typeof el === "string") {
curr.properties ?? (curr.properties = {});
(_a = curr.properties)[el] ?? (_a[el] = { errors: [] });
curr = curr.properties[el];
} else {
curr.items ?? (curr.items = []);
(_b = curr.items)[el] ?? (_b[el] = { errors: [] });
curr = curr.items[el];
}
if (terminal) {
curr.errors.push(mapper(issue2));
}
i++;
}
}
}
};
processError(error47);
return result;
}
function toDotPath(_path) {
const segs = [];
const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
for (const seg of path) {
if (typeof seg === "number")
segs.push(`[${seg}]`);
else if (typeof seg === "symbol")
segs.push(`[${JSON.stringify(String(seg))}]`);
else if (/[^\w$]/.test(seg))
segs.push(`[${JSON.stringify(seg)}]`);
else {
if (segs.length)
segs.push(".");
segs.push(seg);
}
}
return segs.join("");
}
function prettifyError(error47) {
const lines = [];
const issues = [...error47.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
for (const issue2 of issues) {
lines.push(`\u2716 ${issue2.message}`);
if (issue2.path?.length)
lines.push(` \u2192 at ${toDotPath(issue2.path)}`);
}
return lines.join("\n");
}
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/core/parse.js
var _parse = (_Err) => (schema, value, _ctx, _params) => {
const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
const result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise) {
throw new $ZodAsyncError();
}
if (result.issues.length) {
const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, _params?.callee);
throw e;
}
return result.value;
};
var parse = /* @__PURE__ */ _parse($ZodRealError);
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
let result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise)
result = await result;
if (result.issues.length) {
const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, params?.callee);
throw e;
}
return result.value;
};
var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
var _safeParse = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
const result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise) {
throw new $ZodAsyncError();
}
return result.issues.length ? {
success: false,
error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
} : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
let result = schema._zod.run({ value, issues: [] }, ctx);
if (result instanceof Promise)
result = await result;
return result.issues.length ? {
success: false,
error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
} : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
var _encode = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
return _parse(_Err)(schema, value, ctx);
};
var encode = /* @__PURE__ */ _encode($ZodRealError);
var _decode = (_Err) => (schema, value, _ctx) => {
return _parse(_Err)(schema, value, _ctx);
};
var decode = /* @__PURE__ */ _decode($ZodRealError);
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
return _parseAsync(_Err)(schema, value, ctx);
};
var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
return _parseAsync(_Err)(schema, value, _ctx);
};
var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
var _safeEncode = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
return _safeParse(_Err)(schema, value, ctx);
};
var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
var _safeDecode = (_Err) => (schema, value, _ctx) => {
return _safeParse(_Err)(schema, value, _ctx);
};
var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
return _safeParseAsync(_Err)(schema, value, ctx);
};
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
return _safeParseAsync(_Err)(schema, value, _ctx);
};
var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
// ../../node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/core/regexes.js
var regexes_exports = {};
__export(regexes_exports, {
base64: () => base64,
base64url: () => base64url,
bigint: () => bigint,
boolean: () => boolean,
browserEmail: () => browserEmail,
cidrv4: () => cidrv4,
cidrv6: () => cidrv6,
cuid: () => cuid,
cuid2: () => cuid2,
date: () => date,
datetime: () => datetime,
domain: () => domain,
duration: () => duration,
e164: () => e164,
email: () => email,
emoji: () => emoji,
extendedDuration: () => extendedDuration,
guid: () => guid,
hex: () => hex,
hostname: () => hostname,
html5Email: () => html5Email,
idnEmail: () => idnEmail,
integer: () => integer,
ipv4: () => ipv4,
ipv6: () => ipv6,
ksuid: () => ksuid,
lowercase: () => lowercase,
md5_base64: () => md5_base64,
md5_base64url: () => md5_base64url,
md5_hex: () => md5_hex,
nanoid: () => nanoid,
null: () => _null,
number: () => number,
rfc5322Email: () => rfc5322Email,
sha1_base64: () => sha1_base64,
sha1_base64url: () => sha1_base64url,
sha1_hex: () => sha1_hex,
sha256_base64: () => sha256_base64,
sha256_base64url: () => sha256_base64url,
sha256_hex: () => sha256_hex,
sha384_base64: () => sha384_base64,
sha384_base64url: () => sha384_base64url,
sha384_hex: () => sha384_hex,
sha512_base64: () => sha512_base64,
sha512_base64url: () => sha512_base64url,
sha512_hex: () => sha512_hex,
string: () => string,
time: () => time,
ulid: () => ulid,
undefined: () => _undefined,
unicodeEmail: () => unicodeEmail,
uppercase: () => uppercase,
uuid: () => uuid,
uuid4: () => uuid4,
uuid6: () => uuid6,
uuid7: () => uuid7,
xid: () => xid
});
var cuid = /^[cC][^\s-]{8,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
var uuid = (version2) => {
if (!version2)
return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
var uuid4 = /* @__PURE__ */ uuid(4);
var uuid6 = /* @__PURE__ */ uuid(6);
var uuid7 = /* @__PURE__ */ uuid(7);
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
var html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
var rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
var unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
var idnEmail = unicodeEmail;
var browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
function emoji() {
return new RegExp(_emoji, "u");
}
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
var base64url = /^[A-Za-z0-9_-]*$/;
var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578