@happyvertical/utils 0.80.0 → 0.80.2

package/dist/chunks/universal-BeseWxvS.js

@@ -1,934 +0,0 @@
-import { createId as createId$1 } from "@paralleldrive/cuid2";
-import { add, isValid, format, parse, parseISO } from "date-fns";
-import pluralize from "pluralize";
-function toCamelCase(str) {
-  return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-function toScreamingSnakeCase(str) {
-  return str.replace(/([A-Z])/g, "_$1").toUpperCase().replace(/^_/, "");
-}
-function convertType(value, type) {
-  switch (type) {
-    case "number": {
-      const num = Number(value);
-      if (Number.isNaN(num)) {
-        throw new Error(`Cannot convert "${value}" to number: result is NaN`);
-      }
-      return num;
-    }
-    case "boolean":
-      return value.toLowerCase() === "true" || value === "1" || value.toLowerCase() === "yes";
-    case "json":
-      try {
-        return JSON.parse(value);
-      } catch (error) {
-        throw new Error(
-          `Cannot parse "${value}" as JSON: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
-    default:
-      return value;
-  }
-}
-function loadEnvConfig(userOptions = {}, options = {}) {
-  const {
-    prefix = "HAVE",
-    packageName,
-    schema = {},
-    transform = {},
-    allowUnknown = true
-  } = options;
-  const envPrefix = packageName && prefix ? `${prefix}_${packageName.toUpperCase()}_` : prefix ? `${prefix}_` : "";
-  const config = { ...userOptions };
-  const fieldsToScan = allowUnknown ? (
-    // Scan all env vars if allowUnknown is true
-    /* @__PURE__ */ new Set([
-      ...Object.keys(schema),
-      // Also scan environment for any matching vars
-      ...Object.keys(process.env).filter((key) => envPrefix && key.startsWith(envPrefix)).map((key) => {
-        const fieldName = key.slice(envPrefix.length);
-        return toCamelCase(fieldName);
-      })
-    ])
-  ) : (
-    // Only scan schema fields if allowUnknown is false
-    new Set(Object.keys(schema))
-  );
-  for (const fieldName of fieldsToScan) {
-    if (fieldName in userOptions) {
-      continue;
-    }
-    const envVarName = envPrefix ? envPrefix + toScreamingSnakeCase(fieldName) : fieldName;
-    const envValue = process.env[envVarName];
-    if (envValue === void 0) {
-      continue;
-    }
-    const transformFn = transform[fieldName];
-    if (transformFn) {
-      try {
-        config[fieldName] = transformFn(envValue);
-      } catch (error) {
-        console.warn(
-          `Failed to transform ${envVarName}="${envValue}":`,
-          error instanceof Error ? error.message : error
-        );
-      }
-      continue;
-    }
-    const fieldType = schema[fieldName];
-    if (fieldType) {
-      try {
-        config[fieldName] = convertType(envValue, fieldType);
-      } catch (error) {
-        console.warn(
-          `Failed to convert ${envVarName}="${envValue}" to ${fieldType}:`,
-          error instanceof Error ? error.message : error
-        );
-      }
-      continue;
-    }
-    config[fieldName] = envValue;
-  }
-  return config;
-}
-function extractCodeBlock(text, language) {
-  if (!text) {
-    return "";
-  }
-  const langPattern = language ? `${language}\\s*` : "(?:\\w+\\s*)?";
-  const codeBlockRegex = new RegExp(
-    `\`\`\`${langPattern}\\r?\\n([\\s\\S]*?)\\r?\\n\`\`\``,
-    "i"
-  );
-  const match = text.match(codeBlockRegex);
-  if (match?.[1]) {
-    return match[1].trim();
-  }
-  const inlineRegex = /`([^`]+)`/;
-  const inlineMatch = text.match(inlineRegex);
-  if (inlineMatch?.[1]) {
-    return inlineMatch[1].trim();
-  }
-  return "";
-}
-function extractJSON(text) {
-  if (!text) {
-    throw new SyntaxError("Cannot extract JSON from empty text");
-  }
-  let jsonText = extractCodeBlock(text, "json");
-  if (!jsonText) {
-    jsonText = extractCodeBlock(text);
-  }
-  if (!jsonText) {
-    const jsonObjectMatch = text.match(/\{[\s\S]*\}/);
-    const jsonArrayMatch = text.match(/\[[\s\S]*\]/);
-    if (jsonObjectMatch) {
-      jsonText = jsonObjectMatch[0];
-    } else if (jsonArrayMatch) {
-      jsonText = jsonArrayMatch[0];
-    } else {
-      jsonText = text.trim();
-    }
-  }
-  try {
-    return JSON.parse(jsonText);
-  } catch (error) {
-    throw new SyntaxError(
-      `Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-function extractAllCodeBlocks(text, language) {
-  if (!text) {
-    return [];
-  }
-  const langPattern = language ? `${language}\\s*` : "(?:\\w+\\s*)?";
-  const codeBlockRegex = new RegExp(
-    `\`\`\`${langPattern}\\r?\\n([\\s\\S]*?)\\r?\\n\`\`\``,
-    "gi"
-  );
-  const blocks = [];
-  const matches = text.matchAll(codeBlockRegex);
-  for (const match of matches) {
-    if (match[1]) {
-      blocks.push(match[1].trim());
-    }
-  }
-  return blocks;
-}
-function extractFunctionDefinition(code, functionName) {
-  if (!code || !functionName) {
-    return "";
-  }
-  const patterns = [
-    // function foo() { ... }
-    {
-      regex: new RegExp(
-        `function\\s+${functionName}\\s*\\([^)]*\\)\\s*\\{`,
-        "i"
-      ),
-      hasBraces: true
-    },
-    // const foo = function() { ... }
-    {
-      regex: new RegExp(
-        `(?:const|let|var)\\s+${functionName}\\s*=\\s*function\\s*\\([^)]*\\)\\s*\\{`,
-        "i"
-      ),
-      hasBraces: true
-    },
-    // const foo = () => { ... }
-    {
-      regex: new RegExp(
-        `(?:const|let|var)\\s+${functionName}\\s*=\\s*\\([^)]*\\)\\s*=>\\s*\\{`,
-        "i"
-      ),
-      hasBraces: true
-    },
-    // const foo = () => ... (no braces)
-    {
-      regex: new RegExp(
-        `(?:const|let|var)\\s+${functionName}\\s*=\\s*\\([^)]*\\)\\s*=>\\s*[^;]+;?`,
-        "i"
-      ),
-      hasBraces: false
-    }
-  ];
-  for (const { regex, hasBraces } of patterns) {
-    const match = code.match(regex);
-    if (match && match.index !== void 0) {
-      const startIdx = match.index;
-      if (!hasBraces) {
-        return match[0].trim();
-      }
-      const braceIdx = code.indexOf("{", startIdx);
-      if (braceIdx === -1) continue;
-      let idx = braceIdx;
-      let depth = 0;
-      let endIdx = -1;
-      while (idx < code.length) {
-        const char = code[idx];
-        if (char === "{") {
-          depth++;
-        } else if (char === "}") {
-          depth--;
-          if (depth === 0) {
-            endIdx = idx;
-            break;
-          }
-        }
-        idx++;
-      }
-      if (endIdx !== -1) {
-        return code.slice(startIdx, endIdx + 1).trim();
-      }
-    }
-  }
-  return "";
-}
-const DANGEROUS_PATTERNS = [
-  /require\s*\(/i,
-  // No require()
-  /import\s+/i,
-  // No import statements
-  /eval\s*\(/i,
-  // No eval()
-  /Function\s*\(/i,
-  // No Function constructor
-  /process\./i,
-  // No process access
-  /fs\./i,
-  // No filesystem module
-  /child_process/i,
-  // No child process
-  /__dirname/i,
-  // No directory access
-  /__filename/i,
-  // No file access
-  /global\./i
-  // No global object manipulation
-];
-function validateCode(code, options = {}) {
-  const {
-    allowedGlobals,
-    disallowedPatterns = DANGEROUS_PATTERNS,
-    maxLength = 5e4,
-    allowRequire = false,
-    allowImport = false,
-    allowEval = false,
-    checkSyntax = true
-  } = options;
-  const errors = [];
-  const warnings = [];
-  if (!code || code.trim().length === 0) {
-    errors.push("Code is empty");
-    return { valid: false, errors, warnings };
-  }
-  if (code.length > maxLength) {
-    errors.push(
-      `Code exceeds maximum length (${code.length} > ${maxLength} characters)`
-    );
-  }
-  const patternFlags = /* @__PURE__ */ new Map([
-    [DANGEROUS_PATTERNS[0], "require"],
-    // /require\s*\(/i
-    [DANGEROUS_PATTERNS[1], "import"],
-    // /import\s+/i
-    [DANGEROUS_PATTERNS[2], "eval"],
-    // /eval\s*\(/i
-    [DANGEROUS_PATTERNS[3], "eval"]
-    // /Function\s*\(/i - also controlled by allowEval
-    // Patterns 4-9 are always dangerous (process, fs, child_process, etc.)
-  ]);
-  const effectivePatterns = disallowedPatterns.filter((_pattern, index) => {
-    const patternType = patternFlags.get(DANGEROUS_PATTERNS[index]);
-    if (patternType === "require" && allowRequire) {
-      return false;
-    }
-    if (patternType === "import" && allowImport) {
-      return false;
-    }
-    if (patternType === "eval" && allowEval) {
-      return false;
-    }
-    return true;
-  });
-  for (const pattern of effectivePatterns) {
-    if (pattern.test(code)) {
-      errors.push(
-        `Code contains disallowed pattern: ${pattern.source.replace(/\\/g, "")}`
-      );
-    }
-  }
-  if (allowedGlobals) {
-    const undeclaredVars = findUndeclaredVariables(code, allowedGlobals);
-    if (undeclaredVars.length > 0) {
-      warnings.push(
-        `Potentially undeclared variables: ${undeclaredVars.join(", ")}`
-      );
-    }
-  }
-  if (checkSyntax) {
-    const syntaxErrors = checkCodeSyntax(code);
-    errors.push(...syntaxErrors);
-  }
-  const stats = {
-    length: code.length,
-    lines: code.split("\n").length,
-    hasAsync: /\basync\b\s*(function|\([\w\s,={}[\]]*\)\s*=>|\w+\s*\()/m.test(
-      code
-    ),
-    hasArrowFunctions: /=>/.test(code),
-    hasClasses: /\bclass\s+\w+/.test(code)
-  };
-  if (stats.lines > 100) {
-    warnings.push(
-      `Code is long (${stats.lines} lines) - consider breaking into smaller functions`
-    );
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-    stats
-  };
-}
-function checkCodeSyntax(code) {
-  const errors = [];
-  try {
-    new Function(code);
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      const message = error.message;
-      if (message.includes("await is only valid") && /\bawait\b/.test(code)) {
-        try {
-          new Function(`(async function() { ${code} })()`);
-          return errors;
-        } catch (asyncError) {
-          if (asyncError instanceof SyntaxError) {
-            errors.push(`Syntax error: ${asyncError.message}`);
-          }
-        }
-      } else {
-        errors.push(`Syntax error: ${message}`);
-      }
-    }
-  }
-  return errors;
-}
-function findUndeclaredVariables(code, allowedGlobals) {
-  const undeclaredVars = /* @__PURE__ */ new Set();
-  const identifierRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
-  const matches = code.matchAll(identifierRegex);
-  const declaredVars = /* @__PURE__ */ new Set();
-  const declarationRegex = /\b(?:var|let|const|function)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
-  const declarations = code.matchAll(declarationRegex);
-  for (const match of declarations) {
-    if (match[1]) {
-      declaredVars.add(match[1]);
-    }
-  }
-  for (const match of matches) {
-    const identifier = match[1];
-    if (isJavaScriptKeyword(identifier)) {
-      continue;
-    }
-    if (declaredVars.has(identifier)) {
-      continue;
-    }
-    if (allowedGlobals.includes(identifier)) {
-      continue;
-    }
-    if (isCommonBuiltin(identifier)) {
-      continue;
-    }
-    undeclaredVars.add(identifier);
-  }
-  return Array.from(undeclaredVars);
-}
-function isJavaScriptKeyword(word) {
-  const keywords = [
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "export",
-    "extends",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "let",
-    "new",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-    "yield",
-    "async",
-    "await"
-  ];
-  return keywords.includes(word);
-}
-function isCommonBuiltin(word) {
-  const builtins = [
-    "Array",
-    "Object",
-    "String",
-    "Number",
-    "Boolean",
-    "Date",
-    "Math",
-    "JSON",
-    "RegExp",
-    "Error",
-    "Map",
-    "Set",
-    "Promise",
-    "Symbol",
-    "undefined",
-    "null",
-    "true",
-    "false",
-    "console",
-    "parseInt",
-    "parseFloat",
-    "isNaN",
-    "isFinite",
-    "decodeURI",
-    "decodeURIComponent",
-    "encodeURI",
-    "encodeURIComponent"
-  ];
-  return builtins.includes(word);
-}
-function isSafeCode(code) {
-  const result = validateCode(code, {
-    maxLength: 5e4,
-    checkSyntax: true
-  });
-  return result.valid;
-}
-class ConsoleLogger {
-  debug(message, context) {
-    if (context) {
-      console.debug(message, context);
-    } else {
-      console.debug(message);
-    }
-  }
-  info(message, context) {
-    if (context) {
-      console.info(message, context);
-    } else {
-      console.info(message);
-    }
-  }
-  warn(message, context) {
-    if (context) {
-      console.warn(message, context);
-    } else {
-      console.warn(message);
-    }
-  }
-  error(message, context) {
-    if (context) {
-      console.error(message, context);
-    } else {
-      console.error(message);
-    }
-  }
-}
-class NoOpLogger {
-  debug() {
-  }
-  info() {
-  }
-  warn() {
-  }
-  error() {
-  }
-}
-let globalLogger = new ConsoleLogger();
-const setLogger = (logger) => {
-  globalLogger = logger;
-};
-const getLogger = () => {
-  return globalLogger;
-};
-const disableLogging = () => {
-  globalLogger = new NoOpLogger();
-};
-const enableLogging = () => {
-  globalLogger = new ConsoleLogger();
-};
-var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-  ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-  ErrorCode2["API_ERROR"] = "API_ERROR";
-  ErrorCode2["FILE_ERROR"] = "FILE_ERROR";
-  ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  ErrorCode2["DATABASE_ERROR"] = "DATABASE_ERROR";
-  ErrorCode2["PARSING_ERROR"] = "PARSING_ERROR";
-  ErrorCode2["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
-  ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-  return ErrorCode2;
-})(ErrorCode || {});
-class BaseError extends Error {
-  /** Error classification code */
-  code;
-  /** Additional context data for debugging */
-  context;
-  /** When the error occurred */
-  timestamp;
-  constructor(message, code = "UNKNOWN_ERROR", context) {
-    super(message);
-    this.name = this.constructor.name;
-    this.code = code;
-    this.context = context;
-    this.timestamp = /* @__PURE__ */ new Date();
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-  /**
-   * Serializes the error to a JSON-compatible object
-   * @returns Object containing all error properties
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      context: this.context,
-      timestamp: this.timestamp.toISOString(),
-      stack: this.stack
-    };
-  }
-}
-class ValidationError extends BaseError {
-  constructor(message, context) {
-    super(message, "VALIDATION_ERROR", context);
-  }
-}
-class ApiError extends BaseError {
-  constructor(message, context) {
-    super(message, "API_ERROR", context);
-  }
-}
-class FileError extends BaseError {
-  constructor(message, context) {
-    super(message, "FILE_ERROR", context);
-  }
-}
-class NetworkError extends BaseError {
-  constructor(message, context) {
-    super(message, "NETWORK_ERROR", context);
-  }
-}
-class DatabaseError extends BaseError {
-  constructor(message, context) {
-    super(message, "DATABASE_ERROR", context);
-  }
-}
-class ParsingError extends BaseError {
-  constructor(message, context) {
-    super(message, "PARSING_ERROR", context);
-  }
-}
-class TimeoutError extends BaseError {
-  constructor(message, context) {
-    super(message, "TIMEOUT_ERROR", context);
-  }
-}
-const makeId = (type = "cuid2") => {
-  if (type === "cuid2") {
-    return createId$1();
-  }
-  if (crypto?.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-};
-const createId = createId$1;
-const makeSlug = (str) => {
-  const from = "àáâäæãåāăąçćčđďèéêëēėęěğǵḧîïíīįìıİłḿñńǹňôöòóœøōõőṕŕřßśšşșťțûüùúūǘůűųẃẍÿýžźż+·/_,:;";
-  const to = "aaaaaaaaaacccddeeeeeeeegghiiiiiiiilmnnnnoooooooooprrsssssttuuuuuuuuuwxyyzzz--------------";
-  const textToCompare = new RegExp(
-    from.split("").join("|").replace(/\+/g, "\\+"),
-    "g"
-  );
-  return str.toString().toLowerCase().replace("&", "-38-").replace(/\s+/g, "-").replace(textToCompare, (c) => to.charAt(from.indexOf(c))).replace(/[&.]/g, "-").replace(/[^\w-º+]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
-};
-const urlFilename = (url) => {
-  const parsedUrl = new URL(url);
-  const pathSegments = parsedUrl.pathname.split("/");
-  const filename = pathSegments[pathSegments.length - 1];
-  return filename || "index.html";
-};
-const urlPath = (url) => {
-  const parsedUrl = new URL(url);
-  const pathSegments = [
-    parsedUrl.hostname,
-    ...parsedUrl.pathname.split("/").filter(Boolean)
-  ];
-  return pathSegments.join("/");
-};
-const sleep = (duration) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, duration);
-  });
-};
-function waitFor(it, { timeout = 0, delay = 1e3 } = {}) {
-  return new Promise((resolve, reject) => {
-    const beginTime = Date.now();
-    (async function waitATick() {
-      try {
-        const result = await it();
-        if (typeof result !== "undefined") {
-          return resolve(result);
-        }
-        if (timeout > 0) {
-          if (Date.now() > beginTime + timeout) {
-            return reject(
-              new TimeoutError("Function call timed out", {
-                timeout,
-                delay,
-                elapsedTime: Date.now() - beginTime
-              })
-            );
-          }
-        }
-        setTimeout(waitATick, delay);
-      } catch (error) {
-        reject(error);
-      }
-    })();
-  });
-}
-const isArray = (obj) => {
-  return Array.isArray(obj);
-};
-const isPlainObject = (obj) => {
-  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
-};
-const isUrl = (url) => {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-};
-const camelCase = (str) => {
-  return str.toLowerCase().replace(/[-_]+/g, " ").replace(/[^\w\s]/g, "").replace(/\s(.)/g, (_, char) => char.toUpperCase()).replace(/\s/g, "").replace(/^(.)/, (_, char) => char.toLowerCase());
-};
-const snakeCase = (str) => {
-  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/[-\s]+/g, "_");
-};
-const keysToCamel = (obj) => {
-  if (isPlainObject(obj)) {
-    const n = {};
-    Object.keys(obj).forEach((k) => {
-      n[camelCase(k)] = keysToCamel(obj[k]);
-    });
-    return n;
-  }
-  if (isArray(obj)) {
-    return obj.map((i) => keysToCamel(i));
-  }
-  return obj;
-};
-const keysToSnake = (obj) => {
-  if (isPlainObject(obj)) {
-    const n = {};
-    Object.keys(obj).forEach((k) => {
-      n[snakeCase(k)] = keysToSnake(obj[k]);
-    });
-    return n;
-  }
-  if (isArray(obj)) {
-    return obj.map((i) => keysToSnake(i));
-  }
-  return obj;
-};
-const domainToCamel = (domain) => camelCase(domain);
-const logTicker = (tick, options = {}) => {
-  const { chars = [".", "..", "..."] } = options;
-  if (tick) {
-    const index = chars.indexOf(tick);
-    return index + 1 >= chars.length ? chars[0] : chars[index + 1];
-  }
-  return chars[0];
-};
-const parseAmazonDateString = (dateStr) => {
-  const regex = /^([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2})([0-9]{2})([0-9]{2})([A-Z0-9]+)/;
-  const match = dateStr.match(regex);
-  if (!match) {
-    throw new ParsingError("Could not parse Amazon date string", {
-      dateString: dateStr,
-      expectedFormat: "YYYYMMDDTHHMMSSZ"
-    });
-  }
-  const [matched, year, month, day, hour, minutes, seconds, timezone] = match;
-  if (matched !== dateStr) {
-    throw new ParsingError("Invalid Amazon date string format", {
-      dateString: dateStr,
-      matched,
-      expectedFormat: "YYYYMMDDTHHMMSSZ"
-    });
-  }
-  const date = /* @__PURE__ */ new Date(
-    `${year}-${month}-${day}T${hour}:${minutes}:${seconds}${timezone}`
-  );
-  return date;
-};
-const dateInString = (str) => {
-  const cleanStr = str.toLowerCase();
-  const underscoreMatch = str.match(/(\d{4})_(\d{1,2})_(\d{1,2})/);
-  if (underscoreMatch) {
-    const [, year2, month, day2] = underscoreMatch;
-    const date2 = new Date(
-      Number.parseInt(year2, 10),
-      Number.parseInt(month, 10) - 1,
-      Number.parseInt(day2, 10)
-    );
-    if (!Number.isNaN(date2.getTime())) return date2;
-  }
-  const dotMatch = str.match(/(\d{1,2})\.(\d{1,2})\.(\d{4})/);
-  if (dotMatch) {
-    const [, month, day2, year2] = dotMatch;
-    const date2 = new Date(
-      Number.parseInt(year2, 10),
-      Number.parseInt(month, 10) - 1,
-      Number.parseInt(day2, 10)
-    );
-    if (!Number.isNaN(date2.getTime())) return date2;
-  }
-  const isoMatch = cleanStr.match(/(\d{4})[-/](\d{1,2})[-/](\d{1,2})/);
-  if (isoMatch) {
-    const [, year2, month, day2] = isoMatch;
-    const date2 = new Date(
-      Number.parseInt(year2, 10),
-      Number.parseInt(month, 10) - 1,
-      Number.parseInt(day2, 10)
-    );
-    if (!Number.isNaN(date2.getTime())) return date2;
-  }
-  const usMatch = cleanStr.match(/(\d{1,2})[-/](\d{1,2})[-/](\d{4})/);
-  if (usMatch) {
-    const [, month, day2, year2] = usMatch;
-    const date2 = new Date(
-      Number.parseInt(year2, 10),
-      Number.parseInt(month, 10) - 1,
-      Number.parseInt(day2, 10)
-    );
-    if (!Number.isNaN(date2.getTime())) return date2;
-  }
-  const yearMatch = cleanStr.match(/20\d{2}/);
-  if (!yearMatch) return null;
-  const year = Number.parseInt(yearMatch[0], 10);
-  const monthPatterns = {
-    january: 1,
-    jan: 1,
-    february: 2,
-    feb: 2,
-    march: 3,
-    mar: 3,
-    april: 4,
-    apr: 4,
-    may: 5,
-    june: 6,
-    jun: 6,
-    july: 7,
-    jul: 7,
-    august: 8,
-    aug: 8,
-    september: 9,
-    sep: 9,
-    sept: 9,
-    october: 10,
-    oct: 10,
-    november: 11,
-    nov: 11,
-    december: 12,
-    dec: 12
-  };
-  let foundMonth = null;
-  let monthStart = -1;
-  let monthName = "";
-  for (const [name, monthNum] of Object.entries(monthPatterns)) {
-    const monthIndex = cleanStr.indexOf(name);
-    if (monthIndex !== -1) {
-      foundMonth = monthNum;
-      monthStart = monthIndex;
-      monthName = name;
-      break;
-    }
-  }
-  if (!foundMonth) return null;
-  const yearIndex = cleanStr.indexOf(yearMatch[0]);
-  const beforeMonth = cleanStr.substring(
-    Math.max(0, monthStart - 15),
-    monthStart
-  );
-  const afterMonth = cleanStr.substring(
-    monthStart + monthName.length,
-    Math.min(cleanStr.length, monthStart + monthName.length + 15)
-  );
-  const beforeYear = cleanStr.substring(Math.max(0, yearIndex - 15), yearIndex);
-  const afterYear = cleanStr.substring(
-    yearIndex + 4,
-    Math.min(cleanStr.length, yearIndex + 19)
-  );
-  const dayMatch = beforeMonth.match(/(?<!\d)(\d{1,2})\s*$/) || // Day before month (not preceded by another digit)
-  afterMonth.match(/^\s*(\d{1,2})(?!\d)/) || // Day right after month (not followed by another digit)
-  beforeYear.match(/(?<!\d)(\d{1,2})\s*$/) || // Day before year (not preceded by another digit)
-  afterYear.match(/^\s*(\d{1,2})(?!\d)/) || // Day right after year (not followed by another digit)
-  afterMonth.match(/[^\d](\d{1,2})(?!\d)/);
-  const day = dayMatch ? Number.parseInt(dayMatch[1], 10) : 1;
-  if (day < 1 || day > 31) return null;
-  const date = new Date(year, foundMonth - 1, day);
-  return !Number.isNaN(date.getTime()) ? date : null;
-};
-const prettyDate = (dateString) => {
-  const date = new Date(dateString);
-  return new Intl.DateTimeFormat(void 0, {
-    year: "numeric",
-    month: "long",
-    day: "numeric"
-  }).format(date);
-};
-const pluralizeWord = pluralize;
-const singularize = pluralize.singular;
-const isPlural = pluralize.isPlural;
-const isSingular = pluralize.isSingular;
-const formatDate = (date, formatStr = "yyyy-MM-dd") => {
-  const dateObj = typeof date === "string" ? new Date(date) : date;
-  return format(dateObj, formatStr);
-};
-const parseDate = (dateStr, formatStr) => {
-  if (formatStr) {
-    return parse(dateStr, formatStr, /* @__PURE__ */ new Date());
-  }
-  return parseISO(dateStr);
-};
-const isValidDate = isValid;
-const addInterval = add;
-const getTempDirectory = (subfolder) => {
-  const tmpBase = process?.env ? process.env.TMPDIR || process.env.TMP || process.env.TEMP || "/tmp" : "/tmp";
-  const basePath = `${tmpBase}/.have-sdk`;
-  return subfolder ? `${basePath}/${subfolder}` : basePath;
-};
-export {
-  ApiError as A,
-  BaseError as B,
-  makeId as C,
-  DatabaseError as D,
-  ErrorCode as E,
-  FileError as F,
-  makeSlug as G,
-  parseAmazonDateString as H,
-  parseDate as I,
-  pluralizeWord as J,
-  prettyDate as K,
-  setLogger as L,
-  singularize as M,
-  NetworkError as N,
-  sleep as O,
-  ParsingError as P,
-  snakeCase as Q,
-  toCamelCase as R,
-  toScreamingSnakeCase as S,
-  TimeoutError as T,
-  urlFilename as U,
-  ValidationError as V,
-  urlPath as W,
-  validateCode as X,
-  waitFor as Y,
-  addInterval as a,
-  convertType as b,
-  camelCase as c,
-  createId as d,
-  dateInString as e,
-  disableLogging as f,
-  domainToCamel as g,
-  enableLogging as h,
-  extractAllCodeBlocks as i,
-  extractCodeBlock as j,
-  extractFunctionDefinition as k,
-  extractJSON as l,
-  formatDate as m,
-  getLogger as n,
-  getTempDirectory as o,
-  isArray as p,
-  isPlainObject as q,
-  isPlural as r,
-  isSafeCode as s,
-  isSingular as t,
-  isUrl as u,
-  isValidDate as v,
-  keysToCamel as w,
-  keysToSnake as x,
-  loadEnvConfig as y,
-  logTicker as z
-};
-//# sourceMappingURL=universal-BeseWxvS.js.map