@withwiz/toolkit 0.9.3 → 0.10.0

package/dist/{chunk-KMUYO6YD.js → chunk-465MEI5K.js}

@@ -1,6 +1,6 @@
 import {
   clearTokenCookies
-} from "./chunk-BOABYFJ7.js";
+} from "./chunk-6NEGFM32.js";
 
 // src/next/auth-handlers/logout.handler.ts
 import { NextResponse } from "next/server";

package/dist/{chunk-OXKVQGRH.js → chunk-5Z5CZAZP.js}

@@ -1,6 +1,9 @@
+import {
+  corsMiddleware
+} from "./chunk-37VGD4VX.js";
 import {
   errorHandlerMiddleware
-} from "./chunk-4Y5MRUMX.js";
+} from "./chunk-KHXS4DGA.js";
 import {
   initRequestMiddleware
 } from "./chunk-VC2E6KYQ.js";
@@ -20,10 +23,7 @@ import {
   adminMiddleware,
   authMiddleware,
   optionalAuthMiddleware
-} from "./chunk-CNXK3SLK.js";
-import {
-  corsMiddleware
-} from "./chunk-37VGD4VX.js";
+} from "./chunk-HZN44RWL.js";
 
 // src/next/middleware/wrappers.ts
 function withPublicApi(handler) {

package/dist/chunk-BTNM5YSU.js

@@ -0,0 +1,29 @@
+// src/core/api-key/validate.ts
+function validateApiKeyRecord(record, opts) {
+  var _a, _b;
+  if (!record) return { valid: false, error: "INVALID_API_KEY", message: "Invalid API key" };
+  if (!record.isActive) return { valid: false, error: "INACTIVE_API_KEY", message: "API key is inactive" };
+  if (record.expiresAt && record.expiresAt < /* @__PURE__ */ new Date())
+    return { valid: false, error: "EXPIRED_API_KEY", message: "API key has expired" };
+  if (!record.user.isActive) return { valid: false, error: "INACTIVE_USER", message: "User account is inactive" };
+  if (((_a = opts.freemiumPlans) != null ? _a : []).includes(record.user.plan))
+    return { valid: false, error: "PLAN_RESTRICTED", message: "API access is not available for this plan. Please upgrade." };
+  return {
+    valid: true,
+    apiKey: {
+      id: record.id,
+      userId: record.user.id,
+      permissions: record.permissions,
+      rateLimit: record.rateLimit,
+      endpointLimits: (_b = record.endpointLimits) != null ? _b : void 0,
+      ipWhitelist: record.ipWhitelist,
+      environment: record.environment,
+      expiresAt: record.expiresAt
+    },
+    user: { id: record.user.id, email: record.user.email, plan: record.user.plan }
+  };
+}
+
+export {
+  validateApiKeyRecord
+};

package/dist/{chunk-CNXK3SLK.js → chunk-HZN44RWL.js}

@@ -4,15 +4,15 @@ import {
 import {
   ERROR_CODES
 } from "./chunk-XQIAXMRY.js";
-import {
-  logger
-} from "./chunk-QAIN3WNN.js";
 import {
   JWTManager
 } from "./chunk-LWHLB2Y6.js";
 import {
   getTokenDeliveryStrategy
-} from "./chunk-NERL6VYQ.js";
+} from "./chunk-VHRBXD7U.js";
+import {
+  logger
+} from "./chunk-QAIN3WNN.js";
 import {
   getAuthConfig
 } from "./chunk-N3TCQ5BF.js";

package/dist/{chunk-4Y5MRUMX.js → chunk-KHXS4DGA.js}

@@ -1,6 +1,6 @@
 import {
   AUTH_ERROR_CODE_MAP
-} from "./chunk-AYCXN6QJ.js";
+} from "./chunk-R7EFDSPZ.js";
 import {
   AppError
 } from "./chunk-ATAQRXTH.js";
@@ -11,12 +11,12 @@ import {
   ERROR_CODES,
   classifyError
 } from "./chunk-XQIAXMRY.js";
-import {
-  logger
-} from "./chunk-QAIN3WNN.js";
 import {
   AuthError
 } from "./chunk-5GWGARXI.js";
+import {
+  logger
+} from "./chunk-QAIN3WNN.js";
 import {
   __spreadValues
 } from "./chunk-N3ETBM74.js";

package/dist/{chunk-6SDUWMC3.js → chunk-KZ4PDS5K.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-5GWGARXI.js";
 import {
   getTokenDeliveryStrategy
-} from "./chunk-NERL6VYQ.js";
+} from "./chunk-VHRBXD7U.js";
 
 // src/next/auth-handlers/refresh.handler.ts
 import { NextResponse } from "next/server";

package/dist/chunk-L2A6NGW7.js

@@ -0,0 +1,21 @@
+// src/next/oapi/openapi-spec.ts
+function buildOpenApiSpec(input) {
+  var _a, _b;
+  return {
+    openapi: "3.0.3",
+    info: input.info,
+    servers: (_a = input.servers) != null ? _a : [],
+    paths: input.paths,
+    components: {
+      securitySchemes: {
+        ApiKeyAuth: { type: "apiKey", in: "header", name: "X-API-Key" }
+      },
+      schemas: (_b = input.schemas) != null ? _b : {}
+    },
+    security: [{ ApiKeyAuth: [] }]
+  };
+}
+
+export {
+  buildOpenApiSpec
+};

package/dist/chunk-NUHSUAXG.js

@@ -0,0 +1,35 @@
+// src/core/api-key/ip-whitelist.ts
+function isIpInCidr(ip, cidr) {
+  try {
+    const [range, bits] = cidr.split("/");
+    const mask = parseInt(bits, 10);
+    if (Number.isNaN(mask) || mask < 0 || mask > 32) return false;
+    const ipParts = ip.split(".").map(Number);
+    const rangeParts = range.split(".").map(Number);
+    if (ipParts.length !== 4 || rangeParts.length !== 4) return false;
+    if (![...ipParts, ...rangeParts].every((o) => Number.isInteger(o) && o >= 0 && o <= 255)) return false;
+    const ipNum = ipParts[0] << 24 | ipParts[1] << 16 | ipParts[2] << 8 | ipParts[3];
+    const rangeNum = rangeParts[0] << 24 | rangeParts[1] << 16 | rangeParts[2] << 8 | rangeParts[3];
+    const maskNum = mask === 0 ? 0 : ~0 << 32 - mask >>> 0;
+    return (ipNum & maskNum) === (rangeNum & maskNum);
+  } catch (e) {
+    return false;
+  }
+}
+function isIpAllowed(clientIp, whitelist) {
+  if (!whitelist || whitelist.length === 0) return true;
+  const normalizedIp = clientIp.replace(/^::ffff:/, "");
+  for (const allowed of whitelist) {
+    if (allowed.includes("/")) {
+      if (isIpInCidr(normalizedIp, allowed)) return true;
+    } else if (normalizedIp === allowed.replace(/^::ffff:/, "")) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  isIpInCidr,
+  isIpAllowed
+};

package/dist/{chunk-ZVGEGDYF.js → chunk-OII5BXCZ.js}

@@ -1,6 +1,6 @@
 import {
   OAuthManager
-} from "./chunk-V3GEYUBG.js";
+} from "./chunk-ER6LSA4M.js";
 import {
   generateOAuthState,
   setOAuthStateCookie

package/dist/chunk-P4MGYRJM.js

@@ -0,0 +1,162 @@
+import {
+  generateRawKey,
+  hashKey,
+  keyPreview
+} from "./chunk-ZZTBIA57.js";
+import {
+  validateApiKeyRecord
+} from "./chunk-BTNM5YSU.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-N3ETBM74.js";
+
+// src/core/api-key/api-key.service.ts
+var ApiKeyService = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  prefix(env) {
+    return env === "production" ? this.deps.env.prefixProd : this.deps.env.prefixDev;
+  }
+  toInfo(r) {
+    var _a, _b, _c, _d, _e;
+    return {
+      id: r.id,
+      name: r.name,
+      description: (_a = r.description) != null ? _a : void 0,
+      keyPreview: keyPreview(r.key),
+      permissions: r.permissions,
+      environment: r.environment,
+      rateLimit: r.rateLimit,
+      endpointLimits: (_b = r.endpointLimits) != null ? _b : void 0,
+      ipWhitelist: r.ipWhitelist,
+      lastUsedAt: (_c = r.lastUsedAt) != null ? _c : void 0,
+      lastUsedIp: (_d = r.lastUsedIp) != null ? _d : void 0,
+      usageCount: r.usageCount,
+      isActive: r.isActive,
+      expiresAt: (_e = r.expiresAt) != null ? _e : void 0,
+      createdAt: r.createdAt,
+      updatedAt: r.updatedAt
+    };
+  }
+  async requireOwned(id, userId, isAdmin) {
+    const rec = await this.deps.repo.findById(id);
+    if (!rec) throw new Error("API key not found");
+    if (!isAdmin && rec.userId !== userId) throw new Error("Unauthorized");
+    return rec;
+  }
+  async generateApiKey(userId, options, plan) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const { repo, planConfig, env } = this.deps;
+    if (env.restrictedPlans.includes(plan)) {
+      throw new Error(`API key is not available for the ${plan} plan. Please upgrade.`);
+    }
+    const maxKeys = await planConfig.getApiKeyLimit(plan);
+    const active = await repo.countActive(userId);
+    if (active >= maxKeys) throw new Error(`API key limit reached. Max ${maxKeys} keys.`);
+    const rawKey = generateRawKey(this.prefix(options.environment));
+    const planRate = await planConfig.getRateLimit(plan);
+    const rateLimit = options.customRateLimit ? Math.min(options.customRateLimit, planRate) : planRate;
+    const expiresAt = (_a = options.expiresAt) != null ? _a : new Date(Date.now() + env.defaultExpiryDays * 864e5);
+    const created = await repo.create({
+      userId,
+      key: hashKey(rawKey),
+      name: options.name,
+      description: (_b = options.description) != null ? _b : null,
+      permissions: options.permissions,
+      rateLimit,
+      endpointLimits: (_c = options.endpointLimits) != null ? _c : null,
+      environment: options.environment,
+      ipWhitelist: (_d = options.ipWhitelist) != null ? _d : [],
+      expiresAt
+    });
+    return {
+      id: created.id,
+      key: rawKey,
+      name: created.name,
+      description: (_e = created.description) != null ? _e : void 0,
+      permissions: created.permissions,
+      environment: created.environment,
+      rateLimit: created.rateLimit,
+      endpointLimits: (_f = created.endpointLimits) != null ? _f : void 0,
+      expiresAt: (_g = created.expiresAt) != null ? _g : void 0,
+      createdAt: created.createdAt
+    };
+  }
+  async validateApiKey(rawKey) {
+    var _a;
+    const { repo, cache, env } = this.deps;
+    const keyHash = hashKey(rawKey);
+    const cached = await cache.getValidation(keyHash);
+    if (cached) {
+      const exp = (_a = cached.apiKey) == null ? void 0 : _a.expiresAt;
+      if (!(exp && new Date(exp) < /* @__PURE__ */ new Date())) return cached;
+      await cache.invalidate(keyHash);
+    }
+    const record = await repo.findByHash(keyHash);
+    const result = validateApiKeyRecord(record, { freemiumPlans: env.restrictedPlans });
+    if (result.valid) await cache.setValidation(keyHash, result);
+    return result;
+  }
+  async getApiKey(id, userId, isAdmin = false) {
+    const rec = await this.requireOwned(id, userId, isAdmin);
+    return this.toInfo(rec);
+  }
+  async getApiKeys(filters, requesterId, isAdmin = false) {
+    var _a, _b;
+    const scoped = isAdmin ? filters : __spreadProps(__spreadValues({}, filters), { userId: requesterId });
+    const page = (_a = scoped.page) != null ? _a : 1, pageSize = (_b = scoped.pageSize) != null ? _b : 10;
+    const { items, total } = await this.deps.repo.findMany(__spreadProps(__spreadValues({}, scoped), { page, pageSize }));
+    return { keys: items.map((r) => this.toInfo(r)), total, page, pageSize, hasMore: total > page * pageSize };
+  }
+  async updateApiKey(id, userId, data, isAdmin = false) {
+    const rec = await this.requireOwned(id, userId, isAdmin);
+    const updated = await this.deps.repo.update(id, {
+      name: data.name,
+      description: data.description,
+      isActive: data.isActive,
+      permissions: data.permissions,
+      ipWhitelist: data.ipWhitelist,
+      rateLimit: data.customRateLimit,
+      endpointLimits: data.endpointLimits
+    });
+    await this.deps.cache.invalidate(rec.key);
+    return this.toInfo(updated);
+  }
+  async deleteApiKey(id, userId, isAdmin = false) {
+    const rec = await this.requireOwned(id, userId, isAdmin);
+    await this.deps.repo.delete(id);
+    await this.deps.cache.invalidate(rec.key);
+  }
+  async trackUsage(apiKeyId, ip) {
+    try {
+      await this.deps.repo.incrementUsage(apiKeyId, ip);
+    } catch (e) {
+    }
+  }
+  async regenerateApiKey(userId, apiKeyId, plan, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const old = await this.requireOwned(apiKeyId, userId, false);
+    if (!options.keepOldKeyActive) {
+      const max = await this.deps.planConfig.getApiKeyLimit(plan);
+      if (await this.deps.repo.countActive(userId) >= max) throw new Error(`API key limit reached. Max ${max} keys.`);
+      await this.deps.repo.deactivate(apiKeyId);
+      await this.deps.cache.invalidate(old.key);
+    }
+    return this.generateApiKey(userId, {
+      name: (_a = options.name) != null ? _a : old.name,
+      description: (_c = (_b = options.description) != null ? _b : old.description) != null ? _c : void 0,
+      permissions: old.permissions,
+      environment: old.environment,
+      customRateLimit: old.rateLimit,
+      ipWhitelist: old.ipWhitelist,
+      endpointLimits: (_d = old.endpointLimits) != null ? _d : void 0,
+      expiresAt: (_e = old.expiresAt) != null ? _e : void 0
+    }, plan);
+  }
+};
+
+export {
+  ApiKeyService
+};

package/dist/{chunk-ROMGYJFX.js → chunk-SROPI74N.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-LWHLB2Y6.js";
 import {
   getTokenDeliveryStrategy
-} from "./chunk-NERL6VYQ.js";
+} from "./chunk-VHRBXD7U.js";
 import {
   JWT_DEFAULTS
 } from "./chunk-7YWUKMZD.js";

package/dist/{chunk-NERL6VYQ.js → chunk-VHRBXD7U.js}

@@ -1,6 +1,6 @@
 import {
   setTokenCookies
-} from "./chunk-BOABYFJ7.js";
+} from "./chunk-6NEGFM32.js";
 import {
   getAuthConfig
 } from "./chunk-N3TCQ5BF.js";

package/dist/{chunk-ISP4MDKW.js → chunk-W27FQNP6.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-5GWGARXI.js";
 import {
   getTokenDeliveryStrategy
-} from "./chunk-NERL6VYQ.js";
+} from "./chunk-VHRBXD7U.js";
 import {
   JWT_DEFAULTS,
   ROLE_DEFAULTS

package/dist/chunk-XWHT53CZ.js

@@ -0,0 +1,38 @@
+import {
+  isIpAllowed
+} from "./chunk-NUHSUAXG.js";
+
+// src/next/oapi/api-key-auth.ts
+import { NextResponse } from "next/server";
+var err = (code, status, message) => ({ response: NextResponse.json({ success: false, error: { code, message } }, { status }) });
+function createApiKeyAuth(options) {
+  return async (req) => {
+    var _a;
+    try {
+      const apiKey = req.headers.get("x-api-key");
+      if (!apiKey) return err(40101, 401, "X-API-Key header is required");
+      const v = await options.service.validateApiKey(apiKey);
+      if (!v.valid || !v.apiKey || !v.user) return err(40101, 401, v.message || "Invalid API key");
+      const ip = options.extractClientIp(req.headers);
+      if (!isIpAllowed(ip, (_a = v.apiKey.ipWhitelist) != null ? _a : null)) return err(40301, 403, "Access denied: IP not in whitelist");
+      try {
+        const usage = await options.usage.canMakeApiCall(v.user.id, v.user.plan);
+        if (!usage.allowed) {
+          const t = usage.reason === "DAILY_LIMIT" ? "daily" : "monthly";
+          return err(40301, 403, `API ${t} usage limit exceeded. Please upgrade your plan or wait until reset.`);
+        }
+      } catch (e) {
+      }
+      options.service.trackUsage(v.apiKey.id, ip).catch(() => {
+      });
+      const role = await options.resolveRole(v.user.id);
+      return { user: { id: v.user.id, email: v.user.email, role, plan: v.user.plan, apiKeyId: v.apiKey.id } };
+    } catch (e) {
+      return err(50001, 500, "Internal authentication error");
+    }
+  };
+}
+
+export {
+  createApiKeyAuth
+};

package/dist/chunk-Z4J452HD.js

@@ -0,0 +1,24 @@
+// src/next/oapi/helpers.ts
+import { NextResponse } from "next/server";
+function parsePaginationParams(sp) {
+  const page = Math.max(1, parseInt(sp.get("page") || "1", 10) || 1);
+  const pageSize = Math.min(100, Math.max(1, parseInt(sp.get("pageSize") || "10", 10) || 10));
+  return { page, pageSize };
+}
+function createPaginationMeta(total, page, pageSize) {
+  return { total, page, pageSize, hasMore: total > page * pageSize };
+}
+function parseSearchParams(sp) {
+  return { search: sp.get("search") || void 0 };
+}
+function requireParam(value, label) {
+  if (!value) return NextResponse.json({ success: false, error: { code: 40001, message: `${label} is required` } }, { status: 400 });
+  return null;
+}
+
+export {
+  parsePaginationParams,
+  createPaginationMeta,
+  parseSearchParams,
+  requireParam
+};

package/dist/{chunk-VQ47YRFC.js → chunk-Z64GNAB7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-MTZXWVW3.js";
 import {
   OAuthManager
-} from "./chunk-V3GEYUBG.js";
+} from "./chunk-ER6LSA4M.js";
 import {
   OAUTH_STATE_COOKIE,
   clearOAuthStateCookie,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-5GWGARXI.js";
 import {
   setTokenCookies
-} from "./chunk-BOABYFJ7.js";
+} from "./chunk-6NEGFM32.js";
 
 // src/next/auth-handlers/oauth-callback.handler.ts
 import { NextResponse } from "next/server";

package/dist/chunk-ZZTBIA57.js

@@ -0,0 +1,18 @@
+// src/core/api-key/key-generator.ts
+import crypto from "crypto";
+function generateRawKey(prefix) {
+  return `${prefix}${crypto.randomBytes(32).toString("hex")}`;
+}
+function hashKey(rawKey) {
+  return crypto.createHash("sha256").update(rawKey).digest("hex");
+}
+function keyPreview(keyHash) {
+  if (keyHash.length < 14) return keyHash;
+  return `${keyHash.substring(0, 10)}...${keyHash.substring(keyHash.length - 4)}`;
+}
+
+export {
+  generateRawKey,
+  hashKey,
+  keyPreview
+};

package/dist/core/api-key/api-key.service.d.ts

@@ -0,0 +1,28 @@
+import type { IApiKeyRepository, IApiKeyCacheStore, IPlanConfigProvider, IUsageTracker, ApiKeyServiceEnv } from '@withwiz/toolkit/core/api-key/ports';
+import type { CreateApiKeyOptions, ApiKeyResult, ApiKeyValidationResult, ApiKeyInfo, ApiKeyFilters, ApiKeyListResponse, UpdateApiKeyData } from '@withwiz/toolkit/core/api-key/types';
+export interface ApiKeyServiceDeps {
+    repo: IApiKeyRepository;
+    cache: IApiKeyCacheStore;
+    planConfig: IPlanConfigProvider;
+    usage: IUsageTracker;
+    env: ApiKeyServiceEnv;
+}
+export declare class ApiKeyService {
+    private readonly deps;
+    constructor(deps: ApiKeyServiceDeps);
+    private prefix;
+    private toInfo;
+    private requireOwned;
+    generateApiKey(userId: string, options: CreateApiKeyOptions, plan: string): Promise<ApiKeyResult>;
+    validateApiKey(rawKey: string): Promise<ApiKeyValidationResult>;
+    getApiKey(id: string, userId: string, isAdmin?: boolean): Promise<ApiKeyInfo>;
+    getApiKeys(filters: ApiKeyFilters, requesterId: string, isAdmin?: boolean): Promise<ApiKeyListResponse>;
+    updateApiKey(id: string, userId: string, data: UpdateApiKeyData, isAdmin?: boolean): Promise<ApiKeyInfo>;
+    deleteApiKey(id: string, userId: string, isAdmin?: boolean): Promise<void>;
+    trackUsage(apiKeyId: string, ip?: string): Promise<void>;
+    regenerateApiKey(userId: string, apiKeyId: string, plan: string, options?: {
+        name?: string;
+        description?: string;
+        keepOldKeyActive?: boolean;
+    }): Promise<ApiKeyResult>;
+}

package/dist/core/api-key/api-key.service.js

@@ -0,0 +1,9 @@
+import {
+  ApiKeyService
+} from "../../chunk-P4MGYRJM.js";
+import "../../chunk-ZZTBIA57.js";
+import "../../chunk-BTNM5YSU.js";
+import "../../chunk-N3ETBM74.js";
+export {
+  ApiKeyService
+};

package/dist/core/api-key/index.d.ts

@@ -0,0 +1,6 @@
+export * from '@withwiz/toolkit/core/api-key/types';
+export * from '@withwiz/toolkit/core/api-key/ports';
+export * from '@withwiz/toolkit/core/api-key/key-generator';
+export * from '@withwiz/toolkit/core/api-key/ip-whitelist';
+export * from '@withwiz/toolkit/core/api-key/validate';
+export { ApiKeyService, type ApiKeyServiceDeps } from '@withwiz/toolkit/core/api-key/api-key.service';

package/dist/core/api-key/index.js

@@ -0,0 +1,28 @@
+import "../../chunk-MXWSG6ER.js";
+import {
+  ApiKeyService
+} from "../../chunk-P4MGYRJM.js";
+import {
+  isIpAllowed,
+  isIpInCidr
+} from "../../chunk-NUHSUAXG.js";
+import {
+  generateRawKey,
+  hashKey,
+  keyPreview
+} from "../../chunk-ZZTBIA57.js";
+import "../../chunk-CWS5RPRX.js";
+import "../../chunk-TN5ZNYR2.js";
+import {
+  validateApiKeyRecord
+} from "../../chunk-BTNM5YSU.js";
+import "../../chunk-N3ETBM74.js";
+export {
+  ApiKeyService,
+  generateRawKey,
+  hashKey,
+  isIpAllowed,
+  isIpInCidr,
+  keyPreview,
+  validateApiKeyRecord
+};

package/dist/core/api-key/ip-whitelist.d.ts

@@ -0,0 +1,4 @@
+/** IPv4 CIDR 범위 포함 여부. 잘못된 입력은 false(throw 안 함). */
+export declare function isIpInCidr(ip: string, cidr: string): boolean;
+/** 클라이언트 IP가 화이트리스트(단일 IP 또는 CIDR)에 포함되는지. 빈/null이면 모두 허용. */
+export declare function isIpAllowed(clientIp: string, whitelist: string[] | null): boolean;

package/dist/core/api-key/ip-whitelist.js

@@ -0,0 +1,9 @@
+import {
+  isIpAllowed,
+  isIpInCidr
+} from "../../chunk-NUHSUAXG.js";
+import "../../chunk-N3ETBM74.js";
+export {
+  isIpAllowed,
+  isIpInCidr
+};

package/dist/core/api-key/key-generator.d.ts

@@ -0,0 +1,6 @@
+/** prefix + 32바이트 랜덤 hex. */
+export declare function generateRawKey(prefix: string): string;
+/** raw key의 sha256 hex (DB 저장용). */
+export declare function hashKey(rawKey: string): string;
+/** 키 해시 미리보기: 처음 10 + ... + 마지막 4. 14자 미만이면 원본. */
+export declare function keyPreview(keyHash: string): string;

package/dist/core/api-key/key-generator.js

@@ -0,0 +1,11 @@
+import {
+  generateRawKey,
+  hashKey,
+  keyPreview
+} from "../../chunk-ZZTBIA57.js";
+import "../../chunk-N3ETBM74.js";
+export {
+  generateRawKey,
+  hashKey,
+  keyPreview
+};