@withwiz/toolkit 0.1.0

package/dist/chunk-F6LCSFSU.js

@@ -0,0 +1,31 @@
+import {
+  cn
+} from "./chunk-62FLBG6B.js";
+
+// src/components/ui/Alert.tsx
+import { jsx } from "react/jsx-runtime";
+function Alert({ variant = "default", children, className }) {
+  const variantClasses = {
+    default: "bg-background text-foreground",
+    destructive: "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive"
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
+        variantClasses[variant],
+        className
+      ),
+      children
+    }
+  );
+}
+function AlertDescription({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("text-sm [&_p]:leading-relaxed", className), children });
+}
+
+export {
+  Alert,
+  AlertDescription
+};

package/dist/chunk-FOKAATUQ.js

@@ -0,0 +1,62 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/middleware/cors.ts
+import { NextResponse } from "next/server";
+var getAllowedOrigins = () => {
+  const nodeEnv = process.env.NODE_ENV;
+  if (nodeEnv === "production") {
+    return [
+      process.env.NEXT_PUBLIC_APP_URL || "https://tlog.net",
+      "https://www.tlog.net"
+    ].filter(Boolean);
+  }
+  return [
+    "http://localhost:3000",
+    "http://localhost:3001",
+    "http://127.0.0.1:3000",
+    process.env.NEXT_PUBLIC_APP_URL
+  ].filter(Boolean);
+};
+var corsMiddleware = async (context, next) => {
+  const { request } = context;
+  const origin = request.headers.get("origin");
+  const allowedOrigins = getAllowedOrigins();
+  if (request.method === "OPTIONS") {
+    const response2 = new NextResponse(null, { status: 204 });
+    if (origin && allowedOrigins.includes(origin)) {
+      response2.headers.set("Access-Control-Allow-Origin", origin);
+    } else if (allowedOrigins.includes("*")) {
+      response2.headers.set("Access-Control-Allow-Origin", "*");
+    }
+    response2.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+    response2.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With, X-API-Key");
+    response2.headers.set("Access-Control-Max-Age", "86400");
+    response2.headers.set("Access-Control-Allow-Credentials", "true");
+    return response2;
+  }
+  const response = await next();
+  if (origin && allowedOrigins.includes(origin)) {
+    response.headers.set("Access-Control-Allow-Origin", origin);
+    response.headers.set("Access-Control-Allow-Credentials", "true");
+  } else if (allowedOrigins.includes("*") || process.env.NODE_ENV === "test") {
+    response.headers.set("Access-Control-Allow-Origin", origin || "*");
+    response.headers.set("Access-Control-Allow-Credentials", "true");
+  }
+  response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+  response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With, X-API-Key");
+  return response;
+};
+function validateCorsConfiguration() {
+  const allowedOrigins = getAllowedOrigins();
+  const nodeEnv = process.env.NODE_ENV;
+  logger.info(
+    `[CORS Middleware] \u2705 Initialized - Environment: ${nodeEnv}, Allowed Origins: [${allowedOrigins.join(", ")}]`
+  );
+}
+
+export {
+  corsMiddleware,
+  validateCorsConfiguration
+};

package/dist/chunk-FW3IEJ7H.js

@@ -0,0 +1,71 @@
+import {
+  BaseTransport
+} from "./chunk-HGC4CCKB.js";
+
+// src/error/logging/transports/console.ts
+var COLORS = {
+  ["debug" /* DEBUG */]: "\x1B[36m",
+  // Cyan
+  ["info" /* INFO */]: "\x1B[32m",
+  // Green
+  ["warn" /* WARN */]: "\x1B[33m",
+  // Yellow
+  ["error" /* ERROR */]: "\x1B[31m",
+  // Red
+  ["critical" /* CRITICAL */]: "\x1B[35m",
+  // Magenta
+  reset: "\x1B[0m"
+};
+var ConsoleTransport = class extends BaseTransport {
+  constructor(options = {}) {
+    super("console", options.enabled !== false);
+    this.colorize = options.colorize !== false;
+    this.includeTimestamp = options.includeTimestamp !== false;
+  }
+  async log(entry) {
+    const formatted = this.format(entry);
+    this.output(entry.level, formatted);
+  }
+  /**
+   * 로그 포맷팅
+   */
+  format(entry) {
+    const parts = [];
+    if (this.includeTimestamp) {
+      parts.push(`[${entry.timestamp.toISOString()}]`);
+    }
+    const levelText = this.colorize ? `${COLORS[entry.level]}${entry.level.toUpperCase()}${COLORS.reset}` : entry.level.toUpperCase();
+    parts.push(`[${levelText}]`);
+    parts.push(entry.message);
+    if (Object.keys(entry.context).length > 0) {
+      parts.push(JSON.stringify(entry.context, null, 2));
+    }
+    if (entry.error && entry.error.stack) {
+      parts.push(`
+Stack: ${entry.error.stack}`);
+    }
+    return parts.join(" ");
+  }
+  /**
+   * 콘솔 출력
+   */
+  output(level, message) {
+    switch (level) {
+      case "debug" /* DEBUG */:
+      case "info" /* INFO */:
+        console.log(message);
+        break;
+      case "warn" /* WARN */:
+        console.warn(message);
+        break;
+      case "error" /* ERROR */:
+      case "critical" /* CRITICAL */:
+        console.error(message);
+        break;
+    }
+  }
+};
+
+export {
+  ConsoleTransport
+};

package/dist/chunk-G26T2PRQ.js

@@ -0,0 +1,53 @@
+import {
+  PasswordHasher,
+  PasswordValidator
+} from "./chunk-IHXRF3BH.js";
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/auth/core/password/client-helper.ts
+var DEFAULT_PASSWORD_CONFIG = {
+  minLength: 8,
+  maxLength: 128,
+  requireNumber: true,
+  requireUppercase: true,
+  requireLowercase: true,
+  requireSpecialChar: true,
+  bcryptRounds: 12
+};
+function createPasswordValidator(config) {
+  const fullConfig = __spreadValues(__spreadValues({}, DEFAULT_PASSWORD_CONFIG), config);
+  return new PasswordValidator(fullConfig);
+}
+function validatePassword(password, config) {
+  const validator = createPasswordValidator(config);
+  return validator.validate(password);
+}
+function getPasswordStrength(password, config) {
+  const validator = createPasswordValidator(config);
+  return validator.calculateStrength(password);
+}
+function createPasswordSchema(config) {
+  const validator = createPasswordValidator(config);
+  return validator.createZodSchema();
+}
+var defaultPasswordSchema = createPasswordSchema(DEFAULT_PASSWORD_CONFIG);
+var passwordValidator = createPasswordValidator(DEFAULT_PASSWORD_CONFIG);
+function createPasswordHasher(rounds = 12) {
+  if (typeof window !== "undefined") {
+    console.warn("\u26A0\uFE0F WARNING: Password hashing should only be done on the server!");
+  }
+  return new PasswordHasher(rounds);
+}
+
+export {
+  DEFAULT_PASSWORD_CONFIG,
+  createPasswordValidator,
+  validatePassword,
+  getPasswordStrength,
+  createPasswordSchema,
+  defaultPasswordSchema,
+  passwordValidator,
+  createPasswordHasher
+};

package/dist/chunk-G4NI37NN.js

@@ -0,0 +1,257 @@
+import {
+  runCommand,
+  runMacCommand
+} from "./chunk-KWTBD4CM.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/system/memory.ts
+import os from "os";
+function bytesToMB(bytes) {
+  return Math.round(bytes / 1024 / 1024 * 100) / 100;
+}
+async function getMemoryInfo() {
+  try {
+    const platform = os.platform();
+    let total = 0;
+    let free = 0;
+    let used = 0;
+    let percent = 0;
+    let processUsed = 0;
+    if (platform === "darwin") {
+      try {
+        const memsizeOutput = await runMacCommand("sysctl -n hw.memsize");
+        total = parseInt(memsizeOutput.trim()) || 0;
+        if (total > 0) {
+          const vmstatOutput = await runMacCommand("vm_stat");
+          const lines = vmstatOutput.split("\n");
+          let freePages = 0;
+          let activePages = 0;
+          let inactivePages = 0;
+          let wiredPages = 0;
+          let compressedPages = 0;
+          let speculativePages = 0;
+          let purgeablePages = 0;
+          for (const line of lines) {
+            if (line.includes("Pages free:")) {
+              const match = line.match(/Pages free:\s+(\d+)/);
+              if (match) freePages = parseInt(match[1]) || 0;
+            } else if (line.includes("Pages active:")) {
+              const match = line.match(/Pages active:\s+(\d+)/);
+              if (match) activePages = parseInt(match[1]) || 0;
+            } else if (line.includes("Pages inactive:")) {
+              const match = line.match(/Pages inactive:\s+(\d+)/);
+              if (match) inactivePages = parseInt(match[1]) || 0;
+            } else if (line.includes("Pages wired down:")) {
+              const match = line.match(/Pages wired down:\s+(\d+)/);
+              if (match) wiredPages = parseInt(match[1]) || 0;
+            } else if (line.includes("Pages occupied by compressor:")) {
+              const match = line.match(/Pages occupied by compressor:\s+(\d+)/);
+              if (match) compressedPages = parseInt(match[1]) || 0;
+            } else if (line.includes("Pages speculative:")) {
+              const match = line.match(/Pages speculative:\s+(\d+)/);
+              if (match) speculativePages = parseInt(match[1]) || 0;
+            } else if (line.includes("Pages purgeable:")) {
+              const match = line.match(/Pages purgeable:\s+(\d+)/);
+              if (match) purgeablePages = parseInt(match[1]) || 0;
+            }
+          }
+          let pageSize = 16384;
+          try {
+            const pageSizeOutput = await runMacCommand("sysctl -n hw.pagesize");
+            pageSize = parseInt(pageSizeOutput.trim()) || 16384;
+          } catch (e) {
+          }
+          const usedMemory = (activePages + wiredPages + compressedPages + speculativePages) * pageSize;
+          const availableMemory = (freePages + inactivePages + purgeablePages) * pageSize;
+          free = availableMemory;
+          used = usedMemory;
+          percent = total > 0 ? used / total * 100 : 0;
+        } else {
+          throw new Error("Cannot get memory size with sysctl.");
+        }
+      } catch (error) {
+        logger.debug("macOS memory info fetch failed:", error);
+        try {
+          const topOutput = await runMacCommand("top -l 1 -n 0 | grep 'PhysMem'");
+          const memMatch = topOutput.match(/PhysMem:\s+(\d+)G used\s+\((\d+)M wired,\s+(\d+)M compressor\),\s+(\d+)M unused/);
+          if (memMatch) {
+            const usedGB = parseInt(memMatch[1]) || 0;
+            const wiredMB = parseInt(memMatch[2]) || 0;
+            const compressorMB = parseInt(memMatch[3]) || 0;
+            const unusedMB = parseInt(memMatch[4]) || 0;
+            total = (usedGB * 1024 + unusedMB) * 1024 * 1024;
+            used = usedGB * 1024 * 1024 * 1024;
+            free = unusedMB * 1024 * 1024;
+            percent = total > 0 ? used / total * 100 : 0;
+          } else {
+            const memMatchMB = topOutput.match(/PhysMem:\s+(\d+)M used,\s+(\d+)M wired,\s+(\d+)M unused/);
+            if (memMatchMB) {
+              const usedMB = parseInt(memMatchMB[1]) || 0;
+              const wiredMB = parseInt(memMatchMB[2]) || 0;
+              const unusedMB = parseInt(memMatchMB[3]) || 0;
+              total = (usedMB + wiredMB + unusedMB) * 1024 * 1024;
+              used = (usedMB + wiredMB) * 1024 * 1024;
+              free = unusedMB * 1024 * 1024;
+              percent = total > 0 ? used / total * 100 : 0;
+            } else {
+              throw new Error("Cannot parse memory info with top command.");
+            }
+          }
+        } catch (topError) {
+          logger.debug("top fallback failed:", topError);
+          try {
+            const profilerOutput = await runMacCommand("system_profiler SPHardwareDataType | grep 'Memory:'");
+            const memMatch = profilerOutput.match(/Memory:\s+(\d+)\s+GB/);
+            if (memMatch) {
+              const totalGB = parseInt(memMatch[1]) || 0;
+              total = totalGB * 1024 * 1024 * 1024;
+              free = total * 0.2;
+              used = total * 0.8;
+              percent = 80;
+            } else {
+              throw new Error("Cannot parse memory info with system_profiler.");
+            }
+          } catch (profilerError) {
+            logger.debug("system_profiler fallback failed:", profilerError);
+            try {
+              const osTotal = os.totalmem();
+              if (osTotal > 0) {
+                total = osTotal;
+                const osFree = os.freemem();
+                free = osFree;
+                used = total - free;
+                percent = total > 0 ? used / total * 100 : 0;
+              } else {
+                throw new Error("Cannot get memory info with os module.");
+              }
+            } catch (osError) {
+              logger.debug("os module fallback failed:", osError);
+              throw new Error("All memory info retrieval methods failed.");
+            }
+          }
+        }
+      }
+    } else {
+      try {
+        const meminfoOutput = await runCommand("cat /proc/meminfo");
+        const lines = meminfoOutput.split("\n");
+        let memTotal = 0;
+        let memAvailable = 0;
+        let memFree = 0;
+        let buffers = 0;
+        let cached = 0;
+        let slab = 0;
+        for (const line of lines) {
+          if (line.includes("MemTotal:")) {
+            const match = line.match(/MemTotal:\s+(\d+)/);
+            if (match) memTotal = parseInt(match[1]) * 1024;
+          } else if (line.includes("MemAvailable:")) {
+            const match = line.match(/MemAvailable:\s+(\d+)/);
+            if (match) memAvailable = parseInt(match[1]) * 1024;
+          } else if (line.includes("MemFree:")) {
+            const match = line.match(/MemFree:\s+(\d+)/);
+            if (match) memFree = parseInt(match[1]) * 1024;
+          } else if (line.includes("Buffers:")) {
+            const match = line.match(/Buffers:\s+(\d+)/);
+            if (match) buffers = parseInt(match[1]) * 1024;
+          } else if (line.includes("Cached:")) {
+            const match = line.match(/Cached:\s+(\d+)/);
+            if (match) cached = parseInt(match[1]) * 1024;
+          } else if (line.includes("Slab:")) {
+            const match = line.match(/Slab:\s+(\d+)/);
+            if (match) slab = parseInt(match[1]) * 1024;
+          }
+        }
+        total = memTotal;
+        if (memAvailable > 0) {
+          free = memAvailable;
+          used = total - free;
+        } else {
+          const reclaimable = buffers + cached + slab;
+          free = memFree + reclaimable;
+          used = total - free;
+        }
+        percent = total > 0 ? used / total * 100 : 0;
+      } catch (error) {
+        logger.debug("Linux memory info fetch failed:", error);
+        try {
+          const freeOutput = await runCommand("free -b | grep '^Mem:'");
+          const parts = freeOutput.trim().split(/\s+/);
+          if (parts.length >= 4) {
+            total = parseInt(parts[1]) || 0;
+            used = parseInt(parts[2]) || 0;
+            free = parseInt(parts[3]) || 0;
+            percent = total > 0 ? used / total * 100 : 0;
+          } else {
+            throw new Error("Cannot parse free command output.");
+          }
+        } catch (freeError) {
+          logger.debug("free fallback failed:", freeError);
+          try {
+            const vmstatOutput = await runCommand("vmstat -s | head -10");
+            const lines = vmstatOutput.split("\n");
+            let totalKB = 0;
+            let freeKB = 0;
+            for (const line of lines) {
+              if (line.includes("total memory")) {
+                const match = line.match(/(\d+)\s+total memory/);
+                if (match) totalKB = parseInt(match[1]) || 0;
+              } else if (line.includes("free memory")) {
+                const match = line.match(/(\d+)\s+free memory/);
+                if (match) freeKB = parseInt(match[1]) || 0;
+              }
+            }
+            if (totalKB > 0) {
+              total = totalKB * 1024;
+              free = freeKB * 1024;
+              used = total - free;
+              percent = total > 0 ? used / total * 100 : 0;
+            } else {
+              throw new Error("Cannot parse memory info with vmstat.");
+            }
+          } catch (vmstatError) {
+            logger.debug("vmstat fallback failed:", vmstatError);
+            try {
+              const osTotal = os.totalmem();
+              if (osTotal > 0) {
+                total = osTotal;
+                const osFree = os.freemem();
+                free = osFree;
+                used = total - free;
+                percent = total > 0 ? used / total * 100 : 0;
+              } else {
+                throw new Error("Cannot get memory info with os module.");
+              }
+            } catch (osError) {
+              logger.debug("os module fallback failed:", osError);
+              throw new Error("All memory info retrieval methods failed.");
+            }
+          }
+        }
+      }
+    }
+    try {
+      const memUsage = process.memoryUsage();
+      processUsed = memUsage.rss;
+    } catch (error) {
+      logger.debug("Process memory usage fetch failed:", error);
+      processUsed = 0;
+    }
+    return {
+      total: bytesToMB(total),
+      free: bytesToMB(free),
+      used: bytesToMB(used),
+      percent: Math.round(percent * 100) / 100,
+      processUsed: bytesToMB(processUsed)
+    };
+  } catch (error) {
+    logger.error("Memory info fetch error:", error);
+    throw error;
+  }
+}
+
+export {
+  getMemoryInfo
+};

package/dist/chunk-GCZOXUDV.js

@@ -0,0 +1,132 @@
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/utils/cors.ts
+import { NextResponse } from "next/server";
+var globalCorsConfig = {
+  isDevelopment: process.env.NODE_ENV === "development"
+};
+function initCorsConfig(config) {
+  globalCorsConfig = __spreadValues(__spreadValues({}, globalCorsConfig), config);
+}
+function getCorsConfig() {
+  return globalCorsConfig;
+}
+function extractDomainsFromUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname;
+    const protocol = urlObj.protocol;
+    const port = urlObj.port ? `:${urlObj.port}` : "";
+    const domains = [`${protocol}//${hostname}${port}`];
+    if (!hostname.startsWith("www.")) {
+      domains.push(`${protocol}//www.${hostname}${port}`);
+    }
+    return domains;
+  } catch (e) {
+    return [];
+  }
+}
+function getBaseUrl() {
+  return globalCorsConfig.baseUrl || process.env.BASE_URL || process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
+}
+function getAllowedOrigins() {
+  const origins = /* @__PURE__ */ new Set();
+  if (process.env.ALLOWED_ORIGINS) {
+    const envOrigins = process.env.ALLOWED_ORIGINS.split(",").map((origin) => origin.trim()).filter(Boolean);
+    envOrigins.forEach((origin) => origins.add(origin));
+  }
+  const baseUrl = getBaseUrl();
+  if (baseUrl && baseUrl !== "http://localhost:3000") {
+    const extractedDomains = extractDomainsFromUrl(baseUrl);
+    extractedDomains.forEach((domain) => origins.add(domain));
+  }
+  if (globalCorsConfig.additionalOrigins) {
+    globalCorsConfig.additionalOrigins.forEach((origin) => origins.add(origin));
+  }
+  if (globalCorsConfig.isDevelopment || process.env.NODE_ENV === "development") {
+    origins.add("http://localhost:3000");
+    origins.add("http://127.0.0.1:3000");
+  }
+  return Array.from(origins).filter(Boolean);
+}
+function isOriginAllowed(origin) {
+  if (!origin) return true;
+  const isDev = globalCorsConfig.isDevelopment || process.env.NODE_ENV === "development";
+  if (isDev && origin.includes("localhost")) {
+    return true;
+  }
+  return getAllowedOrigins().includes(origin);
+}
+function setCorsHeaders(response, request) {
+  const origin = request == null ? void 0 : request.headers.get("origin");
+  if (isOriginAllowed(origin)) {
+    response.headers.set("Access-Control-Allow-Origin", origin || "*");
+  }
+  response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+  response.headers.set(
+    "Access-Control-Allow-Headers",
+    "Content-Type, Authorization, X-Requested-With, Accept, Origin"
+  );
+  response.headers.set("Access-Control-Max-Age", "86400");
+  response.headers.set("Access-Control-Allow-Credentials", "true");
+  return response;
+}
+function withCORS(handler) {
+  return async (request) => {
+    if (request.method === "OPTIONS") {
+      const response2 = new NextResponse(null, { status: 200 });
+      return setCorsHeaders(response2, request);
+    }
+    const response = await handler(request);
+    const nextResponse = response instanceof NextResponse ? response : new NextResponse(response.body, response);
+    return setCorsHeaders(nextResponse, request);
+  };
+}
+function withRestrictedCORS(handler, allowedOrigins = []) {
+  return async (request) => {
+    const origin = request.headers.get("origin");
+    const restrictedAllowedOrigins = [
+      ...getAllowedOrigins(),
+      ...allowedOrigins
+    ];
+    if (origin && !restrictedAllowedOrigins.includes(origin)) {
+      return new NextResponse("CORS policy violation", { status: 403 });
+    }
+    if (request.method === "OPTIONS") {
+      const response2 = new NextResponse(null, { status: 200 });
+      return setCorsHeaders(response2, request);
+    }
+    const response = await handler(request);
+    const nextResponse = response instanceof NextResponse ? response : new NextResponse(response.body, response);
+    return setCorsHeaders(nextResponse, request);
+  };
+}
+function withPublicCORS(handler) {
+  return async (request) => {
+    if (request.method === "OPTIONS") {
+      const response2 = new NextResponse(null, { status: 200 });
+      response2.headers.set("Access-Control-Allow-Origin", "*");
+      response2.headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      response2.headers.set("Access-Control-Allow-Headers", "Content-Type");
+      response2.headers.set("Access-Control-Max-Age", "86400");
+      return response2;
+    }
+    const response = await handler(request);
+    const nextResponse = response instanceof NextResponse ? response : new NextResponse(response.body, response);
+    nextResponse.headers.set("Access-Control-Allow-Origin", "*");
+    return nextResponse;
+  };
+}
+
+export {
+  initCorsConfig,
+  getCorsConfig,
+  getAllowedOrigins,
+  isOriginAllowed,
+  setCorsHeaders,
+  withCORS,
+  withRestrictedCORS,
+  withPublicCORS
+};

package/dist/chunk-GDWEDUHO.js

@@ -0,0 +1,55 @@
+// src/auth/core/email/token-generator.ts
+import crypto from "crypto";
+var TokenGenerator = class {
+  /**
+   * 안전한 랜덤 토큰 생성
+   *
+   * @param bytes - 바이트 수 (기본: 32)
+   * @returns 16진수 문자열 토큰
+   */
+  static generate(bytes = 32) {
+    return crypto.randomBytes(bytes).toString("hex");
+  }
+  /**
+   * URL-safe 토큰 생성 (Base64URL)
+   *
+   * @param bytes - 바이트 수 (기본: 32)
+   * @returns URL-safe 토큰
+   */
+  static generateUrlSafe(bytes = 32) {
+    return crypto.randomBytes(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  /**
+   * 숫자 PIN 코드 생성
+   *
+   * @param length - PIN 길이 (기본: 6)
+   * @returns 숫자 PIN 코드
+   */
+  static generatePIN(length = 6) {
+    const max = Math.pow(10, length);
+    const pin = crypto.randomInt(0, max);
+    return pin.toString().padStart(length, "0");
+  }
+  /**
+   * 만료 시간 계산
+   *
+   * @param milliseconds - 만료까지의 밀리초
+   * @returns 만료 Date 객체
+   */
+  static calculateExpiry(milliseconds) {
+    return new Date(Date.now() + milliseconds);
+  }
+  /**
+   * 토큰이 만료되었는지 확인
+   *
+   * @param expiryDate - 만료 Date
+   * @returns 만료 여부
+   */
+  static isExpired(expiryDate) {
+    return /* @__PURE__ */ new Date() > expiryDate;
+  }
+};
+
+export {
+  TokenGenerator
+};