@nice2dev/licensing 1.0.10

package/dist/FeatureGate-Da7fCJA5.js

@@ -0,0 +1,1406 @@
+const SEGMENT_LENGTH = 4;
+const NUM_SEGMENTS = 5;
+const KEY_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const TIER_CODES = {
+  trial: 1,
+  personal: 2,
+  team: 3,
+  enterprise: 4,
+  site: 5,
+  oem: 6
+};
+const CODE_TO_TIER = Object.entries(TIER_CODES).reduce(
+  (acc, [tier, code]) => ({ ...acc, [code]: tier }),
+  {}
+);
+function secureRandom(length) {
+  const array = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else {
+    for (let i = 0; i < length; i++) {
+      array[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(array).map((b) => KEY_CHARS[b % KEY_CHARS.length]).join("");
+}
+function calculateChecksum(data) {
+  let hash = 0;
+  for (let i = 0; i < data.length; i++) {
+    const char = data.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  const positive = Math.abs(hash);
+  let checksum = "";
+  let remaining = positive;
+  for (let i = 0; i < SEGMENT_LENGTH; i++) {
+    checksum += KEY_CHARS[remaining % KEY_CHARS.length];
+    remaining = Math.floor(remaining / KEY_CHARS.length);
+  }
+  return checksum;
+}
+function encodeMetadata(tier, year, month) {
+  const tierCode = TIER_CODES[tier];
+  const yearOffset = year - 2024;
+  const encoded = tierCode * 1e3 + yearOffset * 12 + month;
+  let segment = "";
+  let remaining = encoded;
+  for (let i = 0; i < SEGMENT_LENGTH; i++) {
+    segment += KEY_CHARS[remaining % KEY_CHARS.length];
+    remaining = Math.floor(remaining / KEY_CHARS.length);
+  }
+  return segment;
+}
+function decodeMetadata(segment) {
+  let decoded = 0;
+  for (let i = segment.length - 1; i >= 0; i--) {
+    const idx = KEY_CHARS.indexOf(segment[i]);
+    if (idx === -1) {
+      return null;
+    }
+    decoded = decoded * KEY_CHARS.length + idx;
+  }
+  const tierCode = Math.floor(decoded / 1e3);
+  const remainder = decoded % 1e3;
+  const yearOffset = Math.floor(remainder / 12);
+  const month = remainder % 12;
+  const tier = CODE_TO_TIER[tierCode];
+  if (!tier) {
+    return null;
+  }
+  return {
+    tier,
+    year: 2024 + yearOffset,
+    month
+  };
+}
+function generateLicenseKey(tier = "personal") {
+  const now = /* @__PURE__ */ new Date();
+  const metadataSegment = encodeMetadata(tier, now.getFullYear(), now.getMonth());
+  const randomSegments = [
+    secureRandom(SEGMENT_LENGTH),
+    secureRandom(SEGMENT_LENGTH),
+    secureRandom(SEGMENT_LENGTH)
+  ];
+  const dataWithoutChecksum = [metadataSegment, ...randomSegments].join("-");
+  const checksumSegment = calculateChecksum(dataWithoutChecksum);
+  return `${dataWithoutChecksum}-${checksumSegment}`;
+}
+function validateKeyFormat(key) {
+  const pattern = new RegExp(
+    `^[${KEY_CHARS}]{${SEGMENT_LENGTH}}(-[${KEY_CHARS}]{${SEGMENT_LENGTH}}){${NUM_SEGMENTS - 1}}$`
+  );
+  if (!pattern.test(key)) {
+    return false;
+  }
+  const segments = key.split("-");
+  const dataSegments = segments.slice(0, -1).join("-");
+  const providedChecksum = segments[segments.length - 1];
+  const calculatedChecksum = calculateChecksum(dataSegments);
+  return providedChecksum === calculatedChecksum;
+}
+function extractKeyMetadata(key) {
+  if (!validateKeyFormat(key)) {
+    return null;
+  }
+  const segments = key.split("-");
+  return decodeMetadata(segments[0]);
+}
+function generateLicenseInfo(options) {
+  const key = generateLicenseKey(options.tier);
+  const now = /* @__PURE__ */ new Date();
+  const issuedAt = now.toISOString();
+  let expiresAt = null;
+  let graceUntil;
+  if (options.durationDays !== null) {
+    const expiry = new Date(now);
+    expiry.setDate(expiry.getDate() + options.durationDays);
+    expiresAt = expiry.toISOString();
+    if (options.graceDays) {
+      const grace = new Date(expiry);
+      grace.setDate(grace.getDate() + options.graceDays);
+      graceUntil = grace.toISOString();
+    }
+  }
+  return {
+    key,
+    tier: options.tier,
+    status: "valid",
+    licensee: options.licensee,
+    email: options.email,
+    issuedAt,
+    expiresAt,
+    graceUntil,
+    features: options.features ?? getDefaultFeatures(options.tier),
+    maxSeats: options.maxSeats ?? getDefaultSeats(options.tier),
+    activeSeats: 0,
+    boundMachines: [],
+    maxMachines: options.maxMachines ?? getDefaultMachines(options.tier),
+    floatingSeats: options.floatingSeats,
+    metadata: options.metadata
+  };
+}
+function getDefaultFeatures(tier) {
+  const features = ["core", "basic-components"];
+  if (tier === "trial") {
+    features.push("trial-watermark");
+  }
+  if (["personal", "team", "enterprise", "site", "oem"].includes(tier)) {
+    features.push("advanced-components", "theming", "i18n");
+  }
+  if (["team", "enterprise", "site", "oem"].includes(tier)) {
+    features.push("collaboration", "analytics", "priority-support");
+  }
+  if (["enterprise", "site", "oem"].includes(tier)) {
+    features.push("white-label", "sso", "audit-log", "custom-branding", "api-access");
+  }
+  if (["site", "oem"].includes(tier)) {
+    features.push("unlimited-seats", "source-code-access", "dedicated-support");
+  }
+  if (tier === "oem") {
+    features.push("redistribution", "custom-licensing");
+  }
+  return features;
+}
+function getDefaultSeats(tier) {
+  switch (tier) {
+    case "trial":
+      return 1;
+    case "personal":
+      return 1;
+    case "team":
+      return 10;
+    case "enterprise":
+      return 50;
+    case "site":
+      return null;
+    // unlimited
+    case "oem":
+      return null;
+    default:
+      return 1;
+  }
+}
+function getDefaultMachines(tier) {
+  switch (tier) {
+    case "trial":
+      return 1;
+    case "personal":
+      return 2;
+    case "team":
+      return 20;
+    case "enterprise":
+      return 100;
+    case "site":
+      return 1e3;
+    case "oem":
+      return 1e4;
+    default:
+      return 1;
+  }
+}
+function compareTiers(a, b) {
+  return TIER_CODES[a] - TIER_CODES[b];
+}
+function tierMeetsRequirement(userTier, requiredTier) {
+  return compareTiers(userTier, requiredTier) >= 0;
+}
+function maskLicenseKey(key) {
+  const segments = key.split("-");
+  if (segments.length !== NUM_SEGMENTS) {
+    return "****-****-****-****-****";
+  }
+  return `${segments[0]}-****-****-****-${segments[segments.length - 1]}`;
+}
+function normalizeLicenseKey(input) {
+  const cleaned = input.replace(/\s/g, "").toUpperCase();
+  if (cleaned.includes("-")) {
+    return validateKeyFormat(cleaned) ? cleaned : null;
+  }
+  if (cleaned.length === SEGMENT_LENGTH * NUM_SEGMENTS) {
+    const segments = [];
+    for (let i = 0; i < NUM_SEGMENTS; i++) {
+      segments.push(cleaned.substring(i * SEGMENT_LENGTH, (i + 1) * SEGMENT_LENGTH));
+    }
+    const formatted = segments.join("-");
+    return validateKeyFormat(formatted) ? formatted : null;
+  }
+  return null;
+}
+function fnv1aHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function hashToHex(hash) {
+  return hash.toString(16).padStart(8, "0");
+}
+function strongHash(input) {
+  const h1 = fnv1aHash(input);
+  const h2 = fnv1aHash(input + h1.toString());
+  const h3 = fnv1aHash(h2.toString() + input);
+  return hashToHex(h1) + hashToHex(h2) + hashToHex(h3);
+}
+function getWebGLFingerprint() {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl) {
+      return void 0;
+    }
+    const glAny = gl;
+    const debugInfo = glAny.getExtension("WEBGL_debug_renderer_info");
+    if (!debugInfo) {
+      return void 0;
+    }
+    const vendor = glAny.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+    const renderer = glAny.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+    return strongHash(`${vendor}|${renderer}`);
+  } catch {
+    return void 0;
+  }
+}
+function getCanvasFingerprint() {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  try {
+    const canvas = document.createElement("canvas");
+    canvas.width = 200;
+    canvas.height = 50;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return void 0;
+    }
+    ctx.textBaseline = "top";
+    ctx.font = "14px Arial";
+    ctx.fillStyle = "#f60";
+    ctx.fillRect(125, 1, 62, 20);
+    ctx.fillStyle = "#069";
+    ctx.fillText("Nice2Dev Licensing", 2, 15);
+    ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+    ctx.fillText("Nice2Dev Licensing", 4, 17);
+    return strongHash(canvas.toDataURL());
+  } catch {
+    return void 0;
+  }
+}
+function getAudioFingerprint() {
+  if (typeof window === "undefined" || !window.AudioContext) {
+    return Promise.resolve(void 0);
+  }
+  return new Promise((resolve) => {
+    try {
+      const audioContext = new AudioContext();
+      const oscillator = audioContext.createOscillator();
+      const analyser = audioContext.createAnalyser();
+      const gainNode = audioContext.createGain();
+      const scriptProcessor = audioContext.createScriptProcessor(4096, 1, 1);
+      gainNode.gain.value = 0;
+      oscillator.type = "triangle";
+      oscillator.frequency.value = 1e4;
+      oscillator.connect(analyser);
+      analyser.connect(scriptProcessor);
+      scriptProcessor.connect(gainNode);
+      gainNode.connect(audioContext.destination);
+      let fingerprint = "";
+      scriptProcessor.onaudioprocess = (e) => {
+        const buffer = e.inputBuffer.getChannelData(0);
+        fingerprint = strongHash(buffer.slice(0, 100).join(","));
+        scriptProcessor.disconnect();
+        oscillator.disconnect();
+        analyser.disconnect();
+        gainNode.disconnect();
+        audioContext.close();
+        resolve(fingerprint);
+      };
+      oscillator.start(0);
+      setTimeout(() => {
+        if (!fingerprint) {
+          resolve(void 0);
+        }
+      }, 1e3);
+    } catch {
+      resolve(void 0);
+    }
+  });
+}
+function getUserAgentHash() {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return strongHash(navigator.userAgent);
+}
+function getTimezoneInfo() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return "unknown";
+  }
+}
+function getScreenInfo() {
+  if (typeof screen === "undefined") {
+    return void 0;
+  }
+  return `${screen.width}x${screen.height}x${screen.colorDepth}`;
+}
+function getLanguageInfo() {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return navigator.language || navigator.userLanguage || "unknown";
+}
+function getPlatformInfo() {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return navigator.platform;
+}
+function getHardwareConcurrency() {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return navigator.hardwareConcurrency;
+}
+function getDeviceMemory() {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return navigator.deviceMemory;
+}
+async function collectFingerprintData() {
+  var _a, _b;
+  const audioFingerprint = await getAudioFingerprint();
+  return {
+    webglHash: getWebGLFingerprint(),
+    canvasFingerprint: getCanvasFingerprint(),
+    audioFingerprint,
+    userAgentHash: getUserAgentHash(),
+    browserFingerprint: strongHash(
+      [
+        getTimezoneInfo(),
+        getScreenInfo(),
+        getLanguageInfo(),
+        getPlatformInfo(),
+        (_a = getHardwareConcurrency()) == null ? void 0 : _a.toString(),
+        (_b = getDeviceMemory()) == null ? void 0 : _b.toString()
+      ].filter(Boolean).join("|")
+    )
+  };
+}
+async function generateFingerprint() {
+  const data = await collectFingerprintData();
+  const components = [
+    data.webglHash,
+    data.canvasFingerprint,
+    data.audioFingerprint,
+    data.userAgentHash,
+    data.browserFingerprint
+  ].filter(Boolean);
+  if (components.length === 0) {
+    const fallback = Date.now().toString() + Math.random().toString(36);
+    return strongHash(fallback);
+  }
+  return strongHash(components.join(":"));
+}
+async function generateMachineId() {
+  const fingerprint = await generateFingerprint();
+  return fingerprint.substring(0, 16).toUpperCase();
+}
+function compareFingerprintsData(fp1, fp2) {
+  const fields = [
+    "webglHash",
+    "canvasFingerprint",
+    "audioFingerprint",
+    "userAgentHash",
+    "browserFingerprint"
+  ];
+  let matches = 0;
+  let total = 0;
+  for (const field of fields) {
+    const v1 = fp1[field];
+    const v2 = fp2[field];
+    if (v1 !== void 0 || v2 !== void 0) {
+      total++;
+      if (v1 === v2) {
+        matches++;
+      }
+    }
+  }
+  return total > 0 ? matches / total : 0;
+}
+function storeFingerprint(fingerprint) {
+  if (typeof localStorage === "undefined") {
+    return;
+  }
+  try {
+    localStorage.setItem("nice2dev_fp", fingerprint);
+  } catch {
+  }
+}
+function getStoredFingerprint() {
+  if (typeof localStorage === "undefined") {
+    return null;
+  }
+  try {
+    return localStorage.getItem("nice2dev_fp");
+  } catch {
+    return null;
+  }
+}
+async function getOrGenerateFingerprint() {
+  const stored = getStoredFingerprint();
+  if (stored) {
+    return stored;
+  }
+  const fingerprint = await generateFingerprint();
+  storeFingerprint(fingerprint);
+  return fingerprint;
+}
+const DEFAULT_CONFIG = {
+  serverUrl: "https://license.nice2dev.com/api/v1",
+  timeout: 1e4,
+  retries: 3,
+  cacheTtl: 3600,
+  // 1 hour
+  offlineMode: false,
+  telemetryEnabled: false
+};
+const CACHE_PREFIX = "nice2dev_license_";
+class LicenseValidator {
+  constructor(config = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.loadCacheFromStorage();
+  }
+  /**
+   * Validate a license key
+   */
+  async validate(key, fingerprint) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (!validateKeyFormat(key)) {
+      return {
+        valid: false,
+        errorCode: "INVALID_KEY",
+        errorMessage: "Invalid license key format",
+        validatedAt: now
+      };
+    }
+    const cached = this.getFromCache(key);
+    if (cached) {
+      return cached;
+    }
+    const machineFingerprint = fingerprint || await generateMachineId();
+    if (!this.config.offlineMode) {
+      try {
+        const result = await this.validateOnline(key, machineFingerprint);
+        this.setCache(key, result);
+        return result;
+      } catch (error) {
+        console.warn("Online validation failed, trying offline:", error);
+      }
+    }
+    return this.validateOffline(key, machineFingerprint);
+  }
+  /**
+   * Online license validation
+   */
+  async validateOnline(key, fingerprint) {
+    const url = `${this.config.serverUrl}/validate`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let lastError = null;
+    for (let attempt = 0; attempt < (this.config.retries || 1); attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.config.apiKey ? { "X-API-Key": this.config.apiKey } : {}
+          },
+          body: JSON.stringify({
+            licenseKey: key,
+            machineFingerprint: fingerprint,
+            timestamp: now
+          }),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (response.status === 404) {
+            return {
+              valid: false,
+              errorCode: "INVALID_KEY",
+              errorMessage: "License key not found",
+              validatedAt: now
+            };
+          }
+          throw new Error(`Server error: ${response.status}`);
+        }
+        const data = await response.json();
+        return this.parseServerResponse(data, now);
+      } catch (error) {
+        lastError = error;
+        if (attempt < (this.config.retries || 1) - 1) {
+          await new Promise((r) => setTimeout(r, Math.pow(2, attempt) * 1e3));
+        }
+      }
+    }
+    throw lastError || new Error("Validation failed");
+  }
+  /**
+   * Parse server validation response
+   */
+  parseServerResponse(data, validatedAt) {
+    if (data.valid === false) {
+      return {
+        valid: false,
+        errorCode: data.errorCode,
+        errorMessage: data.errorMessage,
+        validatedAt
+      };
+    }
+    const license = data.license;
+    const now = /* @__PURE__ */ new Date();
+    let daysRemaining;
+    let inGracePeriod = false;
+    if (license.expiresAt) {
+      const expiry = new Date(license.expiresAt);
+      const diffMs = expiry.getTime() - now.getTime();
+      daysRemaining = Math.ceil(diffMs / (1e3 * 60 * 60 * 24));
+      if (daysRemaining < 0 && license.graceUntil) {
+        const graceEnd = new Date(license.graceUntil);
+        if (now < graceEnd) {
+          inGracePeriod = true;
+        }
+      }
+    }
+    return {
+      valid: true,
+      license,
+      daysRemaining,
+      inGracePeriod,
+      availableFeatures: license.features,
+      validatedAt
+    };
+  }
+  /**
+   * Offline license validation
+   */
+  validateOffline(key, fingerprint) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadata = extractKeyMetadata(key);
+    if (!metadata) {
+      return {
+        valid: false,
+        errorCode: "INVALID_KEY",
+        errorMessage: "Cannot decode license key",
+        validatedAt: now
+      };
+    }
+    const storedLicense = this.getStoredLicense(key);
+    if (storedLicense) {
+      if (!storedLicense.boundMachines.some((m) => m.startsWith(fingerprint.substring(0, 8)))) {
+        return {
+          valid: false,
+          errorCode: "MACHINE_LIMIT",
+          errorMessage: "This machine is not authorized for this license",
+          validatedAt: now
+        };
+      }
+      if (storedLicense.expiresAt) {
+        const expiry = new Date(storedLicense.expiresAt);
+        const nowDate = /* @__PURE__ */ new Date();
+        if (nowDate > expiry) {
+          if (storedLicense.graceUntil) {
+            const graceEnd = new Date(storedLicense.graceUntil);
+            if (nowDate > graceEnd) {
+              return {
+                valid: false,
+                errorCode: "EXPIRED",
+                errorMessage: "License has expired",
+                validatedAt: now
+              };
+            }
+            return {
+              valid: true,
+              license: storedLicense,
+              inGracePeriod: true,
+              daysRemaining: 0,
+              availableFeatures: storedLicense.features,
+              validatedAt: now
+            };
+          }
+          return {
+            valid: false,
+            errorCode: "EXPIRED",
+            errorMessage: "License has expired",
+            validatedAt: now
+          };
+        }
+        const diffMs = expiry.getTime() - nowDate.getTime();
+        const daysRemaining = Math.ceil(diffMs / (1e3 * 60 * 60 * 24));
+        return {
+          valid: true,
+          license: storedLicense,
+          daysRemaining,
+          inGracePeriod: false,
+          availableFeatures: storedLicense.features,
+          validatedAt: now
+        };
+      }
+      return {
+        valid: true,
+        license: storedLicense,
+        availableFeatures: storedLicense.features,
+        validatedAt: now
+      };
+    }
+    return {
+      valid: true,
+      // Trust the key format
+      license: {
+        key,
+        tier: metadata.tier,
+        status: "pending",
+        // Needs online verification
+        licensee: "Unknown (offline)",
+        email: "",
+        issuedAt: `${metadata.year}-${String(metadata.month + 1).padStart(2, "0")}-01T00:00:00Z`,
+        expiresAt: null,
+        features: [],
+        // Limited features offline
+        maxSeats: null,
+        activeSeats: 0,
+        boundMachines: [fingerprint],
+        maxMachines: 1
+      },
+      availableFeatures: ["core"],
+      // Only core features offline
+      validatedAt: now
+    };
+  }
+  /**
+   * Generate offline activation challenge
+   */
+  async generateChallenge(key) {
+    const fingerprint = await generateMachineId();
+    const challengeId = crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).substring(2) + Date.now().toString(36);
+    const challengeData = JSON.stringify({
+      key,
+      fingerprint,
+      timestamp: Date.now()
+    });
+    const challengeCode = typeof btoa !== "undefined" ? btoa(challengeData) : Buffer.from(challengeData).toString("base64");
+    const expiresAt = /* @__PURE__ */ new Date();
+    expiresAt.setHours(expiresAt.getHours() + 24);
+    return {
+      challengeId,
+      challengeCode,
+      fingerprint,
+      expiresAt: expiresAt.toISOString()
+    };
+  }
+  /**
+   * Apply offline activation response
+   */
+  applyOfflineResponse(response) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const licenseDataJson = typeof atob !== "undefined" ? atob(response.licenseData) : Buffer.from(response.licenseData, "base64").toString("utf-8");
+      const license = JSON.parse(licenseDataJson);
+      this.storeLicense(license);
+      return {
+        valid: true,
+        license,
+        availableFeatures: license.features,
+        validatedAt: now
+      };
+    } catch {
+      return {
+        valid: false,
+        errorCode: "TAMPERED",
+        errorMessage: "Invalid offline activation response",
+        validatedAt: now
+      };
+    }
+  }
+  /**
+   * Check if feature is available
+   */
+  async hasFeature(key, feature) {
+    var _a;
+    const result = await this.validate(key);
+    if (!result.valid) {
+      return false;
+    }
+    return ((_a = result.availableFeatures) == null ? void 0 : _a.includes(feature)) ?? false;
+  }
+  /**
+   * Activate machine for license
+   */
+  async activateMachine(key) {
+    const fingerprint = await generateMachineId();
+    const url = `${this.config.serverUrl}/activate`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.apiKey ? { "X-API-Key": this.config.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey: key,
+          machineFingerprint: fingerprint,
+          machineName: this.getMachineName(),
+          timestamp: now
+        })
+      });
+      if (!response.ok) {
+        const data2 = await response.json();
+        return {
+          valid: false,
+          errorCode: data2.errorCode || "SERVER_ERROR",
+          errorMessage: data2.errorMessage || "Activation failed",
+          validatedAt: now
+        };
+      }
+      const data = await response.json();
+      const license = data.license;
+      this.storeLicense(license);
+      this.clearCache(key);
+      return {
+        valid: true,
+        license,
+        availableFeatures: license.features,
+        validatedAt: now
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errorCode: "NETWORK_ERROR",
+        errorMessage: "Cannot connect to license server",
+        validatedAt: now
+      };
+    }
+  }
+  /**
+   * Deactivate machine from license
+   */
+  async deactivateMachine(key) {
+    const fingerprint = await generateMachineId();
+    const url = `${this.config.serverUrl}/deactivate`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.apiKey ? { "X-API-Key": this.config.apiKey } : {}
+        },
+        body: JSON.stringify({
+          licenseKey: key,
+          machineFingerprint: fingerprint
+        })
+      });
+      if (response.ok) {
+        this.clearStoredLicense(key);
+        this.clearCache(key);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  // ─── Cache Management ─────────────────────────────────────────
+  getFromCache(key) {
+    const cached = this.cache.get(key);
+    if (!cached) {
+      return null;
+    }
+    if (Date.now() > cached.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.result;
+  }
+  setCache(key, result) {
+    const now = Date.now();
+    const ttl = (this.config.cacheTtl || 3600) * 1e3;
+    this.cache.set(key, {
+      result,
+      cachedAt: now,
+      expiresAt: now + ttl
+    });
+    this.saveCacheToStorage();
+  }
+  clearCache(key) {
+    this.cache.delete(key);
+    this.saveCacheToStorage();
+  }
+  // ─── Storage Management ───────────────────────────────────────
+  getStoredLicense(key) {
+    if (typeof localStorage === "undefined") {
+      return null;
+    }
+    try {
+      const data = localStorage.getItem(`${CACHE_PREFIX}info_${key}`);
+      return data ? JSON.parse(data) : null;
+    } catch {
+      return null;
+    }
+  }
+  storeLicense(license) {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    try {
+      localStorage.setItem(`${CACHE_PREFIX}info_${license.key}`, JSON.stringify(license));
+    } catch {
+    }
+  }
+  clearStoredLicense(key) {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    try {
+      localStorage.removeItem(`${CACHE_PREFIX}info_${key}`);
+    } catch {
+    }
+  }
+  loadCacheFromStorage() {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    try {
+      const data = localStorage.getItem(`${CACHE_PREFIX}cache`);
+      if (data) {
+        const parsed = JSON.parse(data);
+        for (const [key, value] of Object.entries(parsed)) {
+          this.cache.set(key, value);
+        }
+      }
+    } catch {
+    }
+  }
+  saveCacheToStorage() {
+    if (typeof localStorage === "undefined") {
+      return;
+    }
+    try {
+      const obj = {};
+      for (const [key, value] of this.cache.entries()) {
+        obj[key] = value;
+      }
+      localStorage.setItem(`${CACHE_PREFIX}cache`, JSON.stringify(obj));
+    } catch {
+    }
+  }
+  getMachineName() {
+    if (typeof navigator !== "undefined") {
+      return navigator.userAgent.split(/[()]/)[1] || "Unknown Device";
+    }
+    return "Server";
+  }
+}
+let globalValidator = null;
+function getValidator(config) {
+  if (!globalValidator || config) {
+    globalValidator = new LicenseValidator(config);
+  }
+  return globalValidator;
+}
+async function validateLicense(key) {
+  return getValidator().validate(key);
+}
+async function isFeatureLicensed(key, feature) {
+  return getValidator().hasFeature(key, feature);
+}
+const featureRegistry = /* @__PURE__ */ new Map();
+const planRegistry = /* @__PURE__ */ new Map();
+function registerFeature(feature) {
+  featureRegistry.set(feature.id, feature);
+}
+function registerFeatures(features) {
+  features.forEach(registerFeature);
+}
+function getFeature(id) {
+  return featureRegistry.get(id);
+}
+function getAllFeatures() {
+  return Array.from(featureRegistry.values());
+}
+function getFeaturesByCategory(category) {
+  return getAllFeatures().filter((f) => f.category === category);
+}
+function registerPlan(plan) {
+  planRegistry.set(plan.id, plan);
+}
+function registerPlans(plans) {
+  plans.forEach(registerPlan);
+}
+function getPlan(tier) {
+  return planRegistry.get(tier);
+}
+function getAllPlans() {
+  return Array.from(planRegistry.values());
+}
+function hasFeature(license, featureId) {
+  if (!license) {
+    return false;
+  }
+  if (license.features.includes(featureId)) {
+    return true;
+  }
+  const feature = getFeature(featureId);
+  if (feature) {
+    return tierMeetsRequirement(license.tier, feature.requiredTier);
+  }
+  return false;
+}
+function hasTier(license, requiredTier) {
+  if (!license) {
+    return false;
+  }
+  return tierMeetsRequirement(license.tier, requiredTier);
+}
+function getAvailableFeatures(license) {
+  if (!license) {
+    return [];
+  }
+  const available = new Set(license.features);
+  for (const feature of getAllFeatures()) {
+    if (tierMeetsRequirement(license.tier, feature.requiredTier)) {
+      available.add(feature.id);
+    }
+  }
+  return Array.from(available);
+}
+function getMissingFeatures(license, targetTier) {
+  const currentFeatures = new Set(license ? getAvailableFeatures(license) : []);
+  const targetFeatures = getDefaultFeatures(targetTier);
+  return getAllFeatures().filter(
+    (f) => targetFeatures.includes(f.id) && !currentFeatures.has(f.id)
+  );
+}
+function checkFeatureAccess(license, featureId) {
+  if (!license) {
+    return {
+      allowed: false,
+      reason: "no-license",
+      requiredTier: "personal"
+    };
+  }
+  if (license.status === "expired") {
+    return {
+      allowed: false,
+      reason: "expired"
+    };
+  }
+  const feature = getFeature(featureId);
+  if (!feature) {
+    return {
+      allowed: license.features.includes(featureId),
+      reason: license.features.includes(featureId) ? void 0 : "feature-not-included"
+    };
+  }
+  if (!tierMeetsRequirement(license.tier, feature.requiredTier)) {
+    return {
+      allowed: false,
+      reason: "tier-insufficient",
+      requiredTier: feature.requiredTier,
+      upgradeTarget: feature.requiredTier
+    };
+  }
+  if (feature.dependencies) {
+    for (const dep of feature.dependencies) {
+      const depResult = checkFeatureAccess(license, dep);
+      if (!depResult.allowed) {
+        return depResult;
+      }
+    }
+  }
+  return { allowed: true };
+}
+const DEFAULT_FEATURES = [
+  // Core features
+  {
+    id: "core",
+    name: "Core Components",
+    description: "Basic UI components",
+    requiredTier: "trial",
+    category: "core"
+  },
+  {
+    id: "basic-components",
+    name: "Basic Components",
+    description: "Buttons, inputs, cards",
+    requiredTier: "trial",
+    category: "core"
+  },
+  // Personal tier
+  {
+    id: "advanced-components",
+    name: "Advanced Components",
+    description: "Data grids, charts, editors",
+    requiredTier: "personal",
+    category: "components"
+  },
+  {
+    id: "theming",
+    name: "Custom Theming",
+    description: "Theme customization",
+    requiredTier: "personal",
+    category: "customization"
+  },
+  {
+    id: "i18n",
+    name: "Internationalization",
+    description: "Multi-language support",
+    requiredTier: "personal",
+    category: "customization"
+  },
+  // Team tier
+  {
+    id: "collaboration",
+    name: "Collaboration",
+    description: "Real-time collaboration features",
+    requiredTier: "team",
+    category: "team"
+  },
+  {
+    id: "analytics",
+    name: "Analytics",
+    description: "Usage analytics dashboard",
+    requiredTier: "team",
+    category: "team"
+  },
+  {
+    id: "priority-support",
+    name: "Priority Support",
+    description: "24-hour response time",
+    requiredTier: "team",
+    category: "support"
+  },
+  // Enterprise tier
+  {
+    id: "white-label",
+    name: "White Labeling",
+    description: "Remove Nice2Dev branding",
+    requiredTier: "enterprise",
+    category: "enterprise"
+  },
+  {
+    id: "sso",
+    name: "Single Sign-On",
+    description: "SAML/OIDC integration",
+    requiredTier: "enterprise",
+    category: "enterprise"
+  },
+  {
+    id: "audit-log",
+    name: "Audit Log",
+    description: "Detailed activity logging",
+    requiredTier: "enterprise",
+    category: "enterprise"
+  },
+  {
+    id: "custom-branding",
+    name: "Custom Branding",
+    description: "Full brand customization",
+    requiredTier: "enterprise",
+    category: "enterprise"
+  },
+  {
+    id: "api-access",
+    name: "API Access",
+    description: "Full REST API access",
+    requiredTier: "enterprise",
+    category: "enterprise"
+  },
+  // Site tier
+  {
+    id: "unlimited-seats",
+    name: "Unlimited Seats",
+    description: "No user limits",
+    requiredTier: "site",
+    category: "site"
+  },
+  {
+    id: "source-code-access",
+    name: "Source Code Access",
+    description: "Access to source code",
+    requiredTier: "site",
+    category: "site"
+  },
+  {
+    id: "dedicated-support",
+    name: "Dedicated Support",
+    description: "Dedicated support engineer",
+    requiredTier: "site",
+    category: "support"
+  },
+  // OEM tier
+  {
+    id: "redistribution",
+    name: "Redistribution Rights",
+    description: "Include in your products",
+    requiredTier: "oem",
+    category: "oem"
+  },
+  {
+    id: "custom-licensing",
+    name: "Custom Licensing",
+    description: "Your own license terms",
+    requiredTier: "oem",
+    category: "oem"
+  },
+  // Trial marker
+  {
+    id: "trial-watermark",
+    name: "Trial Watermark",
+    description: "Watermark for trial versions",
+    requiredTier: "trial",
+    category: "trial"
+  },
+  // Game Engine features
+  {
+    id: "game-editor",
+    name: "Game Editor",
+    description: "Visual game editor",
+    requiredTier: "personal",
+    category: "game-engine"
+  },
+  {
+    id: "game-export",
+    name: "Game Export",
+    description: "Export to various platforms",
+    requiredTier: "team",
+    category: "game-engine"
+  },
+  {
+    id: "game-multiplayer",
+    name: "Multiplayer",
+    description: "Online multiplayer support",
+    requiredTier: "team",
+    category: "game-engine"
+  },
+  {
+    id: "game-build-cloud",
+    name: "Build Cloud",
+    description: "Cloud compilation for games",
+    requiredTier: "enterprise",
+    category: "game-engine"
+  },
+  // Spatial features
+  {
+    id: "spatial-editor",
+    name: "Spatial Editor",
+    description: "Floor plan editor",
+    requiredTier: "personal",
+    category: "spatial"
+  },
+  {
+    id: "spatial-3d",
+    name: "3D Visualization",
+    description: "3D building visualization",
+    requiredTier: "team",
+    category: "spatial"
+  },
+  {
+    id: "spatial-bim",
+    name: "BIM Integration",
+    description: "IFC/BIM file support",
+    requiredTier: "enterprise",
+    category: "spatial"
+  }
+];
+const DEFAULT_PLANS = [
+  {
+    id: "trial",
+    name: "Trial",
+    description: "14-day free trial with all features",
+    priceMonthly: 0,
+    priceYearly: 0,
+    features: ["core", "basic-components", "trial-watermark"],
+    maxSeats: 1,
+    maxMachines: 1,
+    highlights: ["All features for 14 days", "No credit card required"]
+  },
+  {
+    id: "personal",
+    name: "Personal",
+    description: "For individual developers",
+    priceMonthly: 1900,
+    // $19
+    priceYearly: 15900,
+    // $159 (2 months free)
+    features: ["core", "basic-components", "advanced-components", "theming", "i18n"],
+    maxSeats: 1,
+    maxMachines: 2,
+    highlights: ["All UI components", "Custom theming", "Email support"]
+  },
+  {
+    id: "team",
+    name: "Team",
+    description: "For small to medium teams",
+    priceMonthly: 4900,
+    // $49/seat
+    priceYearly: 41900,
+    // $419/seat
+    features: [
+      "core",
+      "basic-components",
+      "advanced-components",
+      "theming",
+      "i18n",
+      "collaboration",
+      "analytics",
+      "priority-support"
+    ],
+    maxSeats: 10,
+    maxMachines: 20,
+    highlights: ["Up to 10 seats", "Collaboration tools", "Priority support"],
+    recommended: true
+  },
+  {
+    id: "enterprise",
+    name: "Enterprise",
+    description: "For large organizations",
+    priceMonthly: 19900,
+    // $199/month base
+    priceYearly: 199900,
+    // $1999/year
+    features: [
+      "core",
+      "basic-components",
+      "advanced-components",
+      "theming",
+      "i18n",
+      "collaboration",
+      "analytics",
+      "priority-support",
+      "white-label",
+      "sso",
+      "audit-log",
+      "custom-branding",
+      "api-access"
+    ],
+    maxSeats: 50,
+    maxMachines: 100,
+    highlights: ["Up to 50 seats", "SSO & SAML", "White labeling", "API access"]
+  },
+  {
+    id: "site",
+    name: "Site License",
+    description: "Unlimited usage for your organization",
+    priceMonthly: 0,
+    // Contact sales
+    priceYearly: 0,
+    features: [
+      "core",
+      "basic-components",
+      "advanced-components",
+      "theming",
+      "i18n",
+      "collaboration",
+      "analytics",
+      "priority-support",
+      "white-label",
+      "sso",
+      "audit-log",
+      "custom-branding",
+      "api-access",
+      "unlimited-seats",
+      "source-code-access",
+      "dedicated-support"
+    ],
+    maxSeats: null,
+    maxMachines: 1e3,
+    highlights: ["Unlimited seats", "Source code access", "Dedicated support engineer"]
+  },
+  {
+    id: "oem",
+    name: "OEM",
+    description: "Embed in your products",
+    priceMonthly: 0,
+    // Contact sales
+    priceYearly: 0,
+    features: [
+      "core",
+      "basic-components",
+      "advanced-components",
+      "theming",
+      "i18n",
+      "collaboration",
+      "analytics",
+      "priority-support",
+      "white-label",
+      "sso",
+      "audit-log",
+      "custom-branding",
+      "api-access",
+      "unlimited-seats",
+      "source-code-access",
+      "dedicated-support",
+      "redistribution",
+      "custom-licensing"
+    ],
+    maxSeats: null,
+    maxMachines: 1e4,
+    highlights: ["Redistribution rights", "Custom licensing", "Full support"]
+  }
+];
+function initializeDefaults() {
+  registerFeatures(DEFAULT_FEATURES);
+  registerPlans(DEFAULT_PLANS);
+}
+initializeDefaults();
+export {
+  initializeDefaults as A,
+  isFeatureLicensed as B,
+  maskLicenseKey as C,
+  normalizeLicenseKey as D,
+  registerFeature as E,
+  registerFeatures as F,
+  registerPlan as G,
+  registerPlans as H,
+  storeFingerprint as I,
+  validateLicense as J,
+  LicenseValidator as L,
+  generateFingerprint as a,
+  collectFingerprintData as b,
+  checkFeatureAccess as c,
+  compareFingerprintsData as d,
+  extractKeyMetadata as e,
+  compareTiers as f,
+  generateMachineId as g,
+  generateLicenseInfo as h,
+  generateLicenseKey as i,
+  getAllFeatures as j,
+  getAllPlans as k,
+  getAvailableFeatures as l,
+  getDefaultFeatures as m,
+  getDefaultMachines as n,
+  getDefaultSeats as o,
+  getFeature as p,
+  getFeaturesByCategory as q,
+  getMissingFeatures as r,
+  getOrGenerateFingerprint as s,
+  tierMeetsRequirement as t,
+  getPlan as u,
+  validateKeyFormat as v,
+  getStoredFingerprint as w,
+  getValidator as x,
+  hasFeature as y,
+  hasTier as z
+};
+//# sourceMappingURL=FeatureGate-Da7fCJA5.js.map