@eudi-verify/embed 0.1.0

package/dist/eudi-verify.iife.js

@@ -0,0 +1,1677 @@
+"use strict";
+var EudiVerify = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    CSS_VARIABLES: () => CSS_VARIABLES,
+    EudiVerifyElement: () => EudiVerifyElement,
+    STATE_MESSAGES: () => STATE_MESSAGES,
+    VERSION: () => VERSION,
+    announce: () => announce,
+    clearAnnouncement: () => clearAnnouncement,
+    createFocusTrap: () => createFocusTrap,
+    createStyles: () => createStyles,
+    getFocusableElements: () => getFocusableElements,
+    getStateId: () => getStateId,
+    renderWidget: () => renderWidget,
+    updateWidgetState: () => updateWidgetState
+  });
+
+  // ../client/dist/index.js
+  var TERMINAL_STATUSES = Object.freeze([
+    "verified",
+    "rejected",
+    "expired",
+    "cancelled",
+    "error"
+  ]);
+  function isTerminalStatus(status) {
+    return TERMINAL_STATUSES.includes(status);
+  }
+  var EudiClientError = class extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "EudiClientError";
+    }
+  };
+  var NetworkError = class extends EudiClientError {
+    cause;
+    constructor(message, cause) {
+      super(message);
+      this.name = "NetworkError";
+      this.cause = cause;
+    }
+  };
+  var ApiResponseError = class extends EudiClientError {
+    statusCode;
+    errorCode;
+    details;
+    constructor(statusCode, response) {
+      super(response.message);
+      this.name = "ApiResponseError";
+      this.statusCode = statusCode;
+      this.errorCode = response.error;
+      this.details = response.details;
+    }
+  };
+  var SessionNotFoundError = class extends ApiResponseError {
+    sessionId;
+    constructor(sessionId) {
+      super(404, { error: "not_found", message: `Session ${sessionId} not found` });
+      this.name = "SessionNotFoundError";
+      this.sessionId = sessionId;
+    }
+  };
+  var RateLimitError = class extends ApiResponseError {
+    retryAfterMs;
+    constructor(retryAfterMs) {
+      super(429, { error: "rate_limit", message: "Rate limit exceeded" });
+      this.name = "RateLimitError";
+      this.retryAfterMs = retryAfterMs;
+    }
+  };
+  function createApiClient(config) {
+    const { baseUrl, timeoutMs = 3e4 } = config;
+    const fetchFn = config.fetch ?? fetch;
+    const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+    async function request(method, path, body) {
+      const url = `${normalizedBaseUrl}${path}`;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetchFn(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          await handleErrorResponse(response, path);
+        }
+        const data = await response.json();
+        return data;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof ApiResponseError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            throw new NetworkError(`Request timeout after ${timeoutMs}ms`);
+          }
+          throw new NetworkError(`Network request failed: ${error.message}`, error);
+        }
+        throw new NetworkError("Unknown network error");
+      }
+    }
+    async function handleErrorResponse(response, path) {
+      const { status } = response;
+      if (status === 404) {
+        const sessionIdMatch = path.match(/\/sessions\/([^/]+)/);
+        if (sessionIdMatch) {
+          throw new SessionNotFoundError(sessionIdMatch[1]);
+        }
+      }
+      if (status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0;
+        throw new RateLimitError(retryAfterMs);
+      }
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = {
+          error: "unknown_error",
+          message: `HTTP ${status}`
+        };
+      }
+      throw new ApiResponseError(status, errorBody);
+    }
+    return {
+      async createSession(verificationRequest) {
+        return request("POST", "/sessions", { request: verificationRequest });
+      },
+      async getSession(sessionId) {
+        return request("GET", `/sessions/${encodeURIComponent(sessionId)}`);
+      },
+      async cancelSession(sessionId) {
+        return request(
+          "POST",
+          `/sessions/${encodeURIComponent(sessionId)}/cancel`
+        );
+      }
+    };
+  }
+  var DEFAULT_CONFIG = {
+    initialIntervalMs: 1e3,
+    maxIntervalMs: 1e4,
+    backoffMultiplier: 2
+  };
+  function createPoller(fn, config = {}) {
+    const { initialIntervalMs, maxIntervalMs, backoffMultiplier } = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    let currentInterval = initialIntervalMs;
+    let timeoutId = null;
+    let running = false;
+    async function poll() {
+      if (!running) return;
+      try {
+        const shouldStop = await fn();
+        if (shouldStop || !running) {
+          running = false;
+          return;
+        }
+      } catch {
+      }
+      if (!running) return;
+      currentInterval = Math.min(
+        currentInterval * backoffMultiplier,
+        maxIntervalMs
+      );
+      timeoutId = setTimeout(() => {
+        void poll();
+      }, currentInterval);
+    }
+    return {
+      start() {
+        if (running) return;
+        running = true;
+        currentInterval = initialIntervalMs;
+        void poll();
+      },
+      stop() {
+        running = false;
+        if (timeoutId !== null) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      },
+      reset() {
+        currentInterval = initialIntervalMs;
+      }
+    };
+  }
+  var EC_LEVELS = { L: 0, M: 1, Q: 2, H: 3 };
+  var VERSION_TABLE = {
+    L: [
+      { version: 1, totalCodewords: 19, ecCodewordsPerBlock: 7, numBlocks: 1 },
+      { version: 2, totalCodewords: 34, ecCodewordsPerBlock: 10, numBlocks: 1 },
+      { version: 3, totalCodewords: 55, ecCodewordsPerBlock: 15, numBlocks: 1 },
+      { version: 4, totalCodewords: 80, ecCodewordsPerBlock: 20, numBlocks: 1 },
+      { version: 5, totalCodewords: 108, ecCodewordsPerBlock: 26, numBlocks: 1 },
+      { version: 6, totalCodewords: 136, ecCodewordsPerBlock: 18, numBlocks: 2 },
+      { version: 7, totalCodewords: 156, ecCodewordsPerBlock: 20, numBlocks: 2 },
+      { version: 8, totalCodewords: 194, ecCodewordsPerBlock: 24, numBlocks: 2 },
+      { version: 9, totalCodewords: 232, ecCodewordsPerBlock: 30, numBlocks: 2 },
+      { version: 10, totalCodewords: 274, ecCodewordsPerBlock: 18, numBlocks: 4 },
+      { version: 11, totalCodewords: 401, ecCodewordsPerBlock: 20, numBlocks: 4 },
+      { version: 12, totalCodewords: 466, ecCodewordsPerBlock: 24, numBlocks: 4 },
+      { version: 13, totalCodewords: 532, ecCodewordsPerBlock: 26, numBlocks: 4 },
+      { version: 14, totalCodewords: 588, ecCodewordsPerBlock: 30, numBlocks: 4 }
+    ],
+    M: [
+      { version: 1, totalCodewords: 16, ecCodewordsPerBlock: 10, numBlocks: 1 },
+      { version: 2, totalCodewords: 28, ecCodewordsPerBlock: 16, numBlocks: 1 },
+      { version: 3, totalCodewords: 44, ecCodewordsPerBlock: 26, numBlocks: 1 },
+      { version: 4, totalCodewords: 64, ecCodewordsPerBlock: 18, numBlocks: 2 },
+      { version: 5, totalCodewords: 86, ecCodewordsPerBlock: 24, numBlocks: 2 },
+      { version: 6, totalCodewords: 108, ecCodewordsPerBlock: 16, numBlocks: 4 },
+      { version: 7, totalCodewords: 124, ecCodewordsPerBlock: 18, numBlocks: 4 },
+      { version: 8, totalCodewords: 154, ecCodewordsPerBlock: 22, numBlocks: 4 },
+      { version: 9, totalCodewords: 182, ecCodewordsPerBlock: 22, numBlocks: 5 },
+      { version: 10, totalCodewords: 216, ecCodewordsPerBlock: 26, numBlocks: 5 }
+    ],
+    Q: [
+      { version: 1, totalCodewords: 13, ecCodewordsPerBlock: 13, numBlocks: 1 },
+      { version: 2, totalCodewords: 22, ecCodewordsPerBlock: 22, numBlocks: 1 },
+      { version: 3, totalCodewords: 34, ecCodewordsPerBlock: 18, numBlocks: 2 },
+      { version: 4, totalCodewords: 48, ecCodewordsPerBlock: 26, numBlocks: 2 },
+      { version: 5, totalCodewords: 62, ecCodewordsPerBlock: 18, numBlocks: 4 },
+      { version: 6, totalCodewords: 76, ecCodewordsPerBlock: 24, numBlocks: 4 },
+      { version: 7, totalCodewords: 88, ecCodewordsPerBlock: 18, numBlocks: 6 },
+      { version: 8, totalCodewords: 110, ecCodewordsPerBlock: 22, numBlocks: 6 },
+      { version: 9, totalCodewords: 132, ecCodewordsPerBlock: 20, numBlocks: 8 },
+      { version: 10, totalCodewords: 154, ecCodewordsPerBlock: 24, numBlocks: 8 }
+    ],
+    H: [
+      { version: 1, totalCodewords: 9, ecCodewordsPerBlock: 17, numBlocks: 1 },
+      { version: 2, totalCodewords: 16, ecCodewordsPerBlock: 28, numBlocks: 1 },
+      { version: 3, totalCodewords: 26, ecCodewordsPerBlock: 22, numBlocks: 2 },
+      { version: 4, totalCodewords: 36, ecCodewordsPerBlock: 16, numBlocks: 4 },
+      { version: 5, totalCodewords: 46, ecCodewordsPerBlock: 22, numBlocks: 4 },
+      { version: 6, totalCodewords: 60, ecCodewordsPerBlock: 28, numBlocks: 4 },
+      { version: 7, totalCodewords: 66, ecCodewordsPerBlock: 26, numBlocks: 5 },
+      { version: 8, totalCodewords: 86, ecCodewordsPerBlock: 26, numBlocks: 6 },
+      { version: 9, totalCodewords: 100, ecCodewordsPerBlock: 24, numBlocks: 8 },
+      { version: 10, totalCodewords: 122, ecCodewordsPerBlock: 28, numBlocks: 8 }
+    ]
+  };
+  var FORMAT_INFO_STRINGS = {
+    0: [1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0],
+    1: [1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1],
+    2: [1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0],
+    3: [1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1],
+    4: [1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1],
+    5: [1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0],
+    6: [1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
+    7: [1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0],
+    8: [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
+    9: [1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1],
+    10: [1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0],
+    11: [1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1],
+    12: [1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1],
+    13: [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0],
+    14: [1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1],
+    15: [1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
+    16: [0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1],
+    17: [0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0],
+    18: [0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1],
+    19: [0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+    20: [0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0],
+    21: [0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1],
+    22: [0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0],
+    23: [0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1],
+    24: [0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
+    25: [0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0],
+    26: [0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1],
+    27: [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0],
+    28: [0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0],
+    29: [0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1],
+    30: [0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0],
+    31: [0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1]
+  };
+  var ALIGNMENT_PATTERNS = [
+    [],
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+    [6, 22, 38],
+    [6, 24, 42],
+    [6, 26, 46],
+    [6, 28, 50],
+    [6, 30, 54],
+    [6, 32, 58],
+    [6, 34, 62],
+    [6, 26, 46, 66]
+  ];
+  function getVersionInfo(dataLength, ecLevel) {
+    const table = VERSION_TABLE[ecLevel];
+    for (const info of table) {
+      const dataCodewords = info.totalCodewords - info.ecCodewordsPerBlock * info.numBlocks;
+      const maxBytes = dataCodewords - (info.version < 10 ? 2 : 3);
+      if (maxBytes >= dataLength) {
+        return info;
+      }
+    }
+    throw new Error(`Data too long for QR code (max ~270 bytes with ${ecLevel} EC)`);
+  }
+  function createByteData(data, version) {
+    const bytes = new TextEncoder().encode(data);
+    const bits = [];
+    bits.push(0, 1, 0, 0);
+    const countBits = version < 10 ? 8 : 16;
+    for (let i = countBits - 1; i >= 0; i--) {
+      bits.push(bytes.length >> i & 1);
+    }
+    for (const byte of bytes) {
+      for (let i = 7; i >= 0; i--) {
+        bits.push(byte >> i & 1);
+      }
+    }
+    bits.push(0, 0, 0, 0);
+    while (bits.length % 8 !== 0) {
+      bits.push(0);
+    }
+    const codewords = [];
+    for (let i = 0; i < bits.length; i += 8) {
+      let byte = 0;
+      for (let j = 0; j < 8; j++) {
+        byte = byte << 1 | (bits[i + j] ?? 0);
+      }
+      codewords.push(byte);
+    }
+    return codewords;
+  }
+  var GF_EXP = new Uint8Array(512);
+  var GF_LOG = new Uint8Array(256);
+  (function initGaloisField() {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+      GF_EXP[i] = x;
+      GF_LOG[x] = i;
+      x <<= 1;
+      if (x & 256) x ^= 285;
+    }
+    for (let i = 255; i < 512; i++) {
+      GF_EXP[i] = GF_EXP[i - 255];
+    }
+  })();
+  function gfMul(a, b) {
+    if (a === 0 || b === 0) return 0;
+    return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+  }
+  function generateECCodewords(data, numECCodewords) {
+    const gen = [1];
+    for (let i = 0; i < numECCodewords; i++) {
+      const newGen = new Array(gen.length + 1).fill(0);
+      for (let j = 0; j < gen.length; j++) {
+        newGen[j] ^= gen[j];
+        newGen[j + 1] ^= gfMul(gen[j], GF_EXP[i]);
+      }
+      gen.length = newGen.length;
+      for (let j = 0; j < newGen.length; j++) gen[j] = newGen[j];
+    }
+    const msg = [...data, ...new Array(numECCodewords).fill(0)];
+    for (let i = 0; i < data.length; i++) {
+      const coef = msg[i];
+      if (coef !== 0) {
+        for (let j = 0; j < gen.length; j++) {
+          msg[i + j] ^= gfMul(gen[j], coef);
+        }
+      }
+    }
+    return msg.slice(data.length);
+  }
+  function interleaveBlocks(dataCodewords, info) {
+    const { numBlocks, ecCodewordsPerBlock, totalCodewords } = info;
+    const totalDataCodewords = totalCodewords - numBlocks * ecCodewordsPerBlock;
+    const smallBlockSize = Math.floor(totalDataCodewords / numBlocks);
+    const largeBlockCount = totalDataCodewords % numBlocks;
+    const dataBlocks = [];
+    const ecBlocks = [];
+    let offset = 0;
+    for (let i = 0; i < numBlocks; i++) {
+      const blockSize = smallBlockSize + (i >= numBlocks - largeBlockCount ? 1 : 0);
+      const block = dataCodewords.slice(offset, offset + blockSize);
+      offset += blockSize;
+      dataBlocks.push(block);
+      ecBlocks.push(generateECCodewords(block, ecCodewordsPerBlock));
+    }
+    const result = [];
+    const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));
+    for (let i = 0; i < maxDataLen; i++) {
+      for (const block of dataBlocks) {
+        if (i < block.length) result.push(block[i]);
+      }
+    }
+    for (let i = 0; i < ecCodewordsPerBlock; i++) {
+      for (const block of ecBlocks) {
+        result.push(block[i]);
+      }
+    }
+    return result;
+  }
+  function createMatrix(version) {
+    const size = version * 4 + 17;
+    const matrix = Array.from(
+      { length: size },
+      () => new Array(size).fill(null)
+    );
+    function setFinderPattern(row, col) {
+      for (let r = -1; r <= 7; r++) {
+        for (let c = -1; c <= 7; c++) {
+          const nr = row + r;
+          const nc = col + c;
+          if (nr < 0 || nr >= size || nc < 0 || nc >= size) continue;
+          const isOuter = r === -1 || r === 7 || c === -1 || c === 7;
+          const isInner = r >= 1 && r <= 5 && c >= 1 && c <= 5;
+          const isCore = r >= 2 && r <= 4 && c >= 2 && c <= 4;
+          matrix[nr][nc] = isOuter ? 0 : isCore ? 1 : isInner ? 0 : 1;
+        }
+      }
+    }
+    setFinderPattern(0, 0);
+    setFinderPattern(0, size - 7);
+    setFinderPattern(size - 7, 0);
+    for (let i = 8; i < size - 8; i++) {
+      matrix[6][i] = i % 2 === 0 ? 1 : 0;
+      matrix[i][6] = i % 2 === 0 ? 1 : 0;
+    }
+    matrix[size - 8][8] = 1;
+    if (version >= 2) {
+      const positions = ALIGNMENT_PATTERNS[version];
+      for (const row of positions) {
+        for (const col of positions) {
+          if (matrix[row][col] !== null) continue;
+          for (let r = -2; r <= 2; r++) {
+            for (let c = -2; c <= 2; c++) {
+              const isOuter = Math.abs(r) === 2 || Math.abs(c) === 2;
+              const isCore = r === 0 && c === 0;
+              matrix[row + r][col + c] = isOuter || isCore ? 1 : 0;
+            }
+          }
+        }
+      }
+    }
+    return matrix;
+  }
+  function placeData(matrix, codewords) {
+    const size = matrix.length;
+    let bitIndex = 0;
+    const bits = [];
+    for (const cw of codewords) {
+      for (let i = 7; i >= 0; i--) {
+        bits.push(cw >> i & 1);
+      }
+    }
+    let col = size - 1;
+    let goingUp = true;
+    while (col > 0) {
+      if (col === 6) col--;
+      for (let row = goingUp ? size - 1 : 0; goingUp ? row >= 0 : row < size; row += goingUp ? -1 : 1) {
+        for (const offset of [0, -1]) {
+          const c = col + offset;
+          if (c < 0 || matrix[row][c] !== null) continue;
+          matrix[row][c] = bitIndex < bits.length ? bits[bitIndex++] : 0;
+        }
+      }
+      col -= 2;
+      goingUp = !goingUp;
+    }
+  }
+  function applyMask(matrix, maskPattern) {
+    const size = matrix.length;
+    const maskFns = [
+      (r, c) => (r + c) % 2 === 0,
+      (r) => r % 2 === 0,
+      (_, c) => c % 3 === 0,
+      (r, c) => (r + c) % 3 === 0,
+      (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+      (r, c) => r * c % 2 + r * c % 3 === 0,
+      (r, c) => (r * c % 2 + r * c % 3) % 2 === 0,
+      (r, c) => ((r + c) % 2 + r * c % 3) % 2 === 0
+    ];
+    const maskFn = maskFns[maskPattern];
+    const reserved = createReservedMask(size);
+    for (let r = 0; r < size; r++) {
+      for (let c = 0; c < size; c++) {
+        if (!reserved[r][c] && maskFn(r, c)) {
+          matrix[r][c] ^= 1;
+        }
+      }
+    }
+  }
+  function createReservedMask(size) {
+    const reserved = Array.from(
+      { length: size },
+      () => new Array(size).fill(false)
+    );
+    for (let i = 0; i < 8; i++) {
+      for (let j = 0; j < 8; j++) {
+        reserved[i][j] = true;
+        reserved[i][size - 8 + j] = true;
+        reserved[size - 8 + i][j] = true;
+      }
+    }
+    for (let i = 0; i < 9; i++) {
+      reserved[i][8] = true;
+      reserved[8][i] = true;
+      reserved[size - 8 + i - 1][8] = true;
+      reserved[8][size - 8 + i - 1] = true;
+    }
+    for (let i = 0; i < size; i++) {
+      reserved[6][i] = true;
+      reserved[i][6] = true;
+    }
+    return reserved;
+  }
+  function addFormatInfo(matrix, ecLevel, maskPattern) {
+    const formatIndex = EC_LEVELS[ecLevel] * 8 + maskPattern;
+    const bits = FORMAT_INFO_STRINGS[formatIndex];
+    const size = matrix.length;
+    for (let i = 0; i < 6; i++) {
+      matrix[8][i] = bits[i];
+      matrix[i][8] = bits[14 - i];
+    }
+    matrix[8][7] = bits[6];
+    matrix[8][8] = bits[7];
+    matrix[7][8] = bits[8];
+    for (let i = 0; i < 7; i++) {
+      matrix[8][size - 1 - i] = bits[14 - i];
+      matrix[size - 1 - i][8] = bits[i];
+    }
+    matrix[size - 8][8] = bits[7];
+  }
+  function evaluatePenalty(matrix) {
+    const size = matrix.length;
+    let penalty = 0;
+    for (let r = 0; r < size; r++) {
+      let count = 1;
+      for (let c = 1; c < size; c++) {
+        if (matrix[r][c] === matrix[r][c - 1]) {
+          count++;
+          if (count === 5) penalty += 3;
+          else if (count > 5) penalty++;
+        } else {
+          count = 1;
+        }
+      }
+    }
+    for (let c = 0; c < size; c++) {
+      let count = 1;
+      for (let r = 1; r < size; r++) {
+        if (matrix[r][c] === matrix[r - 1][c]) {
+          count++;
+          if (count === 5) penalty += 3;
+          else if (count > 5) penalty++;
+        } else {
+          count = 1;
+        }
+      }
+    }
+    return penalty;
+  }
+  function generateQRMatrix(data, ecLevel) {
+    const info = getVersionInfo(data.length, ecLevel);
+    const dataCodewords = createByteData(data, info.version);
+    const totalDataCodewords = info.totalCodewords - info.numBlocks * info.ecCodewordsPerBlock;
+    while (dataCodewords.length < totalDataCodewords) {
+      dataCodewords.push(dataCodewords.length % 2 === 0 ? 236 : 17);
+    }
+    const codewords = interleaveBlocks(dataCodewords, info);
+    const baseMatrix = createMatrix(info.version);
+    placeData(baseMatrix, codewords);
+    let bestMatrix = null;
+    let bestPenalty = Infinity;
+    for (let mask = 0; mask < 8; mask++) {
+      const matrix = baseMatrix.map(
+        (row) => row.map((cell) => cell === null ? 0 : cell)
+      );
+      applyMask(matrix, mask);
+      addFormatInfo(matrix, ecLevel, mask);
+      const penalty = evaluatePenalty(matrix);
+      if (penalty < bestPenalty) {
+        bestPenalty = penalty;
+        bestMatrix = matrix;
+      }
+    }
+    return bestMatrix;
+  }
+  function generateQRSvg(data, options = {}) {
+    const { size = 200, errorCorrection = "L", quietZone = 4 } = options;
+    const matrix = generateQRMatrix(data, errorCorrection);
+    const moduleCount = matrix.length;
+    const totalModules = moduleCount + quietZone * 2;
+    const moduleSize = size / totalModules;
+    let paths = "";
+    for (let r = 0; r < moduleCount; r++) {
+      for (let c = 0; c < moduleCount; c++) {
+        if (matrix[r][c] === 1) {
+          const x = (c + quietZone) * moduleSize;
+          const y = (r + quietZone) * moduleSize;
+          paths += `M${x},${y}h${moduleSize}v${moduleSize}h-${moduleSize}z`;
+        }
+      }
+    }
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}"><rect width="100%" height="100%" fill="white"/><path d="${paths}" fill="black"/></svg>`;
+  }
+  function generateQRDataUrl(data, options = {}) {
+    const svg = generateQRSvg(data, options);
+    const encoded = encodeURIComponent(svg).replace(/'/g, "%27").replace(/"/g, "%22");
+    return `data:image/svg+xml,${encoded}`;
+  }
+  function createVerification(config) {
+    const { apiUrl, polling, qr, fetch: fetchFn } = config;
+    const client = createApiClient({ baseUrl: apiUrl, fetch: fetchFn });
+    const subscribers = /* @__PURE__ */ new Set();
+    let currentState = { status: "idle" };
+    let currentSessionId = null;
+    let poller = null;
+    function setState(newState) {
+      currentState = newState;
+      for (const callback of subscribers) {
+        try {
+          callback(newState);
+        } catch {
+        }
+      }
+    }
+    function mapSessionToState(session) {
+      switch (session.status) {
+        case "pending":
+          if (session.qrUrl) {
+            return {
+              status: "showQR",
+              qrDataUrl: generateQRDataUrl(session.qrUrl, qr),
+              qrUrl: session.qrUrl,
+              sessionId: session.id
+            };
+          }
+          return { status: "loading" };
+        case "waiting_for_wallet":
+          return { status: "waitingForWallet", sessionId: session.id };
+        case "verified":
+          return {
+            status: "verified",
+            token: session.token,
+            claims: session.claims
+          };
+        case "rejected":
+          return { status: "rejected", error: session.error };
+        case "expired":
+          return { status: "expired" };
+        case "cancelled":
+          return { status: "idle" };
+        case "error":
+          return { status: "error", error: session.error ?? "Verification failed" };
+        default:
+          return { status: "error", error: "Unknown session status" };
+      }
+    }
+    async function pollSession() {
+      if (!currentSessionId) return true;
+      try {
+        const session = await client.getSession(currentSessionId);
+        const newState = mapSessionToState(session);
+        if (newState.status !== currentState.status || newState.status === "showQR" && currentState.status === "showQR" && newState.sessionId !== currentState.sessionId) {
+          setState(newState);
+        }
+        if (isTerminalStatus(session.status)) {
+          return true;
+        }
+        return false;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        setState({ status: "error", error: errorMessage });
+        return true;
+      }
+    }
+    function stopPolling() {
+      if (poller) {
+        poller.stop();
+        poller = null;
+      }
+    }
+    function startPolling() {
+      stopPolling();
+      poller = createPoller(pollSession, polling);
+      poller.start();
+    }
+    return {
+      get state() {
+        return currentState;
+      },
+      async start(request) {
+        stopPolling();
+        currentSessionId = null;
+        setState({ status: "loading" });
+        try {
+          const session = await client.createSession(request);
+          currentSessionId = session.id;
+          const newState = mapSessionToState(session);
+          setState(newState);
+          if (!isTerminalStatus(session.status)) {
+            startPolling();
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          setState({ status: "error", error: errorMessage });
+        }
+      },
+      async cancel() {
+        if (!currentSessionId) return;
+        stopPolling();
+        try {
+          await client.cancelSession(currentSessionId);
+          currentSessionId = null;
+          setState({ status: "idle" });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Failed to cancel";
+          setState({ status: "error", error: errorMessage });
+        }
+      },
+      destroy() {
+        stopPolling();
+        currentSessionId = null;
+        subscribers.clear();
+      },
+      subscribe(callback) {
+        subscribers.add(callback);
+        try {
+          callback(currentState);
+        } catch {
+        }
+        return () => {
+          subscribers.delete(callback);
+        };
+      }
+    };
+  }
+
+  // src/styles.ts
+  var CSS_VARIABLES = {
+    "--eudi-primary": "#003399",
+    "--eudi-text": "#1a1a1a",
+    "--eudi-background": "#ffffff",
+    "--eudi-border-radius": "8px",
+    "--eudi-font-family": "system-ui, sans-serif",
+    "--eudi-error": "#d32f2f"
+  };
+  function createStyles() {
+    return (
+      /* css */
+      `
+    :host {
+      display: block;
+      font-family: var(--eudi-font-family, ${CSS_VARIABLES["--eudi-font-family"]});
+      color: var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]});
+    }
+
+    :host([hidden]) {
+      display: none;
+    }
+
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+    }
+
+    .eudi-widget {
+      background: var(--eudi-background, ${CSS_VARIABLES["--eudi-background"]});
+      border: 1px solid color-mix(in srgb, var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]}) 20%, transparent);
+      border-radius: var(--eudi-border-radius, ${CSS_VARIABLES["--eudi-border-radius"]});
+      padding: 24px;
+      text-align: center;
+      min-width: 280px;
+      max-width: 400px;
+      margin-inline: auto;
+    }
+
+    /* State containers - only one visible at a time */
+    .eudi-state {
+      display: none;
+    }
+
+    .eudi-state[data-active] {
+      display: block;
+    }
+
+    /* Start button */
+    .eudi-start-btn {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      padding: 12px 24px;
+      font-size: 16px;
+      font-weight: 500;
+      font-family: inherit;
+      color: #ffffff;
+      background: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      border: none;
+      border-radius: var(--eudi-border-radius, ${CSS_VARIABLES["--eudi-border-radius"]});
+      cursor: pointer;
+      transition: background-color 0.2s ease, transform 0.1s ease;
+    }
+
+    .eudi-start-btn:hover {
+      background: color-mix(in srgb, var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]}) 85%, black);
+    }
+
+    .eudi-start-btn:focus-visible {
+      outline: 2px solid var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      outline-offset: 2px;
+    }
+
+    .eudi-start-btn:active {
+      transform: scale(0.98);
+    }
+
+    /* EU stars icon */
+    .eudi-icon {
+      width: 20px;
+      height: 20px;
+      flex-shrink: 0;
+    }
+
+    /* Loading state */
+    .eudi-loading {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 12px;
+      padding: 16px 0;
+    }
+
+    .eudi-spinner {
+      width: 40px;
+      height: 40px;
+      border: 3px solid color-mix(in srgb, var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]}) 20%, transparent);
+      border-top-color: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      border-radius: 50%;
+      animation: eudi-spin 0.8s linear infinite;
+    }
+
+    @keyframes eudi-spin {
+      to {
+        transform: rotate(360deg);
+      }
+    }
+
+    /* Reduced motion */
+    @media (prefers-reduced-motion: reduce) {
+      .eudi-spinner {
+        animation: none;
+        border-top-color: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+        border-right-color: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      }
+
+      .eudi-start-btn {
+        transition: none;
+      }
+    }
+
+    /* QR code state */
+    .eudi-qr {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 16px;
+    }
+
+    .eudi-qr-img {
+      width: 200px;
+      height: 200px;
+      border: 1px solid color-mix(in srgb, var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]}) 15%, transparent);
+      border-radius: 4px;
+    }
+
+    .eudi-qr-text {
+      margin: 0;
+      font-size: 14px;
+      color: color-mix(in srgb, var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]}) 80%, transparent);
+    }
+
+    .eudi-cancel-btn {
+      margin-top: 8px;
+      padding: 8px 16px;
+      font-size: 14px;
+      font-family: inherit;
+      color: var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]});
+      background: transparent;
+      border: 1px solid color-mix(in srgb, var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]}) 30%, transparent);
+      border-radius: var(--eudi-border-radius, ${CSS_VARIABLES["--eudi-border-radius"]});
+      cursor: pointer;
+      transition: background-color 0.2s ease;
+    }
+
+    .eudi-cancel-btn:hover {
+      background: color-mix(in srgb, var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]}) 5%, transparent);
+    }
+
+    .eudi-cancel-btn:focus-visible {
+      outline: 2px solid var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      outline-offset: 2px;
+    }
+
+    /* Waiting for wallet */
+    .eudi-waiting {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 12px;
+      padding: 16px 0;
+    }
+
+    .eudi-waiting-icon {
+      width: 48px;
+      height: 48px;
+      color: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+    }
+
+    .eudi-waiting-text {
+      margin: 0;
+      font-size: 16px;
+    }
+
+    /* Success state */
+    .eudi-success {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 12px;
+      padding: 16px 0;
+    }
+
+    .eudi-success-icon {
+      width: 48px;
+      height: 48px;
+      color: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+    }
+
+    .eudi-success-text {
+      margin: 0;
+      font-size: 18px;
+      font-weight: 500;
+      color: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+    }
+
+    /* Error/rejected/expired states */
+    .eudi-error {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 12px;
+      padding: 16px 0;
+    }
+
+    .eudi-error-icon {
+      width: 48px;
+      height: 48px;
+      color: var(--eudi-error, ${CSS_VARIABLES["--eudi-error"]});
+    }
+
+    .eudi-error-text {
+      margin: 0;
+      font-size: 16px;
+      color: var(--eudi-error, ${CSS_VARIABLES["--eudi-error"]});
+    }
+
+    .eudi-error-detail {
+      margin: 0;
+      font-size: 14px;
+      color: color-mix(in srgb, var(--eudi-text, ${CSS_VARIABLES["--eudi-text"]}) 70%, transparent);
+    }
+
+    .eudi-retry-btn {
+      margin-top: 8px;
+      padding: 10px 20px;
+      font-size: 14px;
+      font-weight: 500;
+      font-family: inherit;
+      color: #ffffff;
+      background: var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      border: none;
+      border-radius: var(--eudi-border-radius, ${CSS_VARIABLES["--eudi-border-radius"]});
+      cursor: pointer;
+      transition: background-color 0.2s ease;
+    }
+
+    .eudi-retry-btn:hover {
+      background: color-mix(in srgb, var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]}) 85%, black);
+    }
+
+    .eudi-retry-btn:focus-visible {
+      outline: 2px solid var(--eudi-primary, ${CSS_VARIABLES["--eudi-primary"]});
+      outline-offset: 2px;
+    }
+
+    /* Screen reader only */
+    .eudi-sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border: 0;
+    }
+
+    /* Demo mode banner */
+    .eudi-demo-banner {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      padding: 8px 12px;
+      margin-bottom: 16px;
+      font-size: 13px;
+      color: #7c5c00;
+      background: #fef3cd;
+      border: 1px solid #ffe69c;
+      border-radius: 4px;
+    }
+
+    .eudi-demo-banner[hidden] {
+      display: none;
+    }
+
+    .eudi-warning-icon {
+      width: 16px;
+      height: 16px;
+      flex-shrink: 0;
+      color: #7c5c00;
+    }
+  `
+    );
+  }
+
+  // src/render.ts
+  var EU_STARS_ICON = (
+    /* html */
+    `
+<svg class="eudi-icon" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
+  <circle cx="12" cy="12" r="10" fill="none" stroke="currentColor" stroke-width="1.5"/>
+  <g fill="currentColor">
+    <polygon points="12,4 12.5,5.5 14,5.5 12.75,6.5 13.25,8 12,7 10.75,8 11.25,6.5 10,5.5 11.5,5.5"/>
+    <polygon points="17,6.5 17.35,7.6 18.5,7.6 17.6,8.3 17.9,9.4 17,8.7 16.1,9.4 16.4,8.3 15.5,7.6 16.65,7.6"/>
+    <polygon points="19,11 19.35,12.1 20.5,12.1 19.6,12.8 19.9,13.9 19,13.2 18.1,13.9 18.4,12.8 17.5,12.1 18.65,12.1"/>
+    <polygon points="17,15.5 17.35,16.6 18.5,16.6 17.6,17.3 17.9,18.4 17,17.7 16.1,18.4 16.4,17.3 15.5,16.6 16.65,16.6"/>
+    <polygon points="12,18 12.35,19.1 13.5,19.1 12.6,19.8 12.9,20.9 12,20.2 11.1,20.9 11.4,19.8 10.5,19.1 11.65,19.1"/>
+    <polygon points="7,15.5 7.35,16.6 8.5,16.6 7.6,17.3 7.9,18.4 7,17.7 6.1,18.4 6.4,17.3 5.5,16.6 6.65,16.6"/>
+    <polygon points="5,11 5.35,12.1 6.5,12.1 5.6,12.8 5.9,13.9 5,13.2 4.1,13.9 4.4,12.8 3.5,12.1 4.65,12.1"/>
+    <polygon points="7,6.5 7.35,7.6 8.5,7.6 7.6,8.3 7.9,9.4 7,8.7 6.1,9.4 6.4,8.3 5.5,7.6 6.65,7.6"/>
+  </g>
+</svg>
+`
+  );
+  var SUCCESS_ICON = (
+    /* html */
+    `
+<svg class="eudi-success-icon" viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <circle cx="12" cy="12" r="10" stroke="currentColor" stroke-width="2"/>
+  <path d="M8 12l3 3 5-6" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
+`
+  );
+  var ERROR_ICON = (
+    /* html */
+    `
+<svg class="eudi-error-icon" viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <circle cx="12" cy="12" r="10" stroke="currentColor" stroke-width="2"/>
+  <path d="M15 9l-6 6M9 9l6 6" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+</svg>
+`
+  );
+  var EXPIRED_ICON = (
+    /* html */
+    `
+<svg class="eudi-error-icon" viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <circle cx="12" cy="12" r="10" stroke="currentColor" stroke-width="2"/>
+  <path d="M12 6v6l4 2" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+</svg>
+`
+  );
+  var WALLET_ICON = (
+    /* html */
+    `
+<svg class="eudi-waiting-icon" viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <rect x="2" y="6" width="20" height="14" rx="2" stroke="currentColor" stroke-width="2"/>
+  <path d="M2 10h20" stroke="currentColor" stroke-width="2"/>
+  <circle cx="17" cy="14" r="1.5" fill="currentColor"/>
+</svg>
+`
+  );
+  var WARNING_ICON = (
+    /* html */
+    `
+<svg class="eudi-warning-icon" viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <path d="M12 9v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
+`
+  );
+  function getStateId(status) {
+    return `eudi-state-${status}`;
+  }
+  function renderIdle() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("idle")}" class="eudi-state" data-active>
+      <button class="eudi-start-btn" type="button" data-action="start">
+        ${EU_STARS_ICON}
+        <span>Verify with EU Wallet</span>
+      </button>
+    </div>
+  `
+    );
+  }
+  function renderLoading() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("loading")}" class="eudi-state">
+      <div class="eudi-loading">
+        <div class="eudi-spinner" aria-hidden="true"></div>
+        <p>Loading...</p>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderShowQR() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("showQR")}" class="eudi-state">
+      <div class="eudi-qr">
+        <img class="eudi-qr-img" src="" alt="Scan with EUDI Wallet" />
+        <p class="eudi-qr-text">Scan with your EU Digital Identity Wallet</p>
+        <button class="eudi-cancel-btn" type="button" data-action="cancel">Cancel</button>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderWaitingForWallet() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("waitingForWallet")}" class="eudi-state">
+      <div class="eudi-waiting">
+        ${WALLET_ICON}
+        <p class="eudi-waiting-text">Waiting for wallet approval...</p>
+        <button class="eudi-cancel-btn" type="button" data-action="cancel">Cancel</button>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderVerified() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("verified")}" class="eudi-state">
+      <div class="eudi-success">
+        ${SUCCESS_ICON}
+        <p class="eudi-success-text">Verified</p>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderRejected() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("rejected")}" class="eudi-state">
+      <div class="eudi-error">
+        ${ERROR_ICON}
+        <p class="eudi-error-text">Verification declined</p>
+        <p class="eudi-error-detail"></p>
+        <button class="eudi-retry-btn" type="button" data-action="reset">Try again</button>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderExpired() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("expired")}" class="eudi-state">
+      <div class="eudi-error">
+        ${EXPIRED_ICON}
+        <p class="eudi-error-text">Session expired</p>
+        <button class="eudi-retry-btn" type="button" data-action="reset">Try again</button>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderError() {
+    return (
+      /* html */
+      `
+    <div id="${getStateId("error")}" class="eudi-state">
+      <div class="eudi-error">
+        ${ERROR_ICON}
+        <p class="eudi-error-text">Verification failed</p>
+        <p class="eudi-error-detail"></p>
+        <button class="eudi-retry-btn" type="button" data-action="reset">Try again</button>
+      </div>
+    </div>
+  `
+    );
+  }
+  function renderDemoBanner() {
+    return (
+      /* html */
+      `
+    <div class="eudi-demo-banner" role="status" aria-live="polite" hidden>
+      ${WARNING_ICON}
+      <span>Demo mode \u2014 credentials are simulated</span>
+    </div>
+  `
+    );
+  }
+  function renderWidget() {
+    return (
+      /* html */
+      `
+    <div class="eudi-widget" role="region" aria-label="Identity verification">
+      <div class="eudi-sr-only" aria-live="polite" aria-atomic="true"></div>
+      ${renderDemoBanner()}
+      ${renderIdle()}
+      ${renderLoading()}
+      ${renderShowQR()}
+      ${renderWaitingForWallet()}
+      ${renderVerified()}
+      ${renderRejected()}
+      ${renderExpired()}
+      ${renderError()}
+    </div>
+  `
+    );
+  }
+  function updateWidgetState(container, state) {
+    const stateContainers = container.querySelectorAll(".eudi-state");
+    for (const stateEl of stateContainers) {
+      if (stateEl.id === getStateId(state.status)) {
+        stateEl.setAttribute("data-active", "");
+      } else {
+        stateEl.removeAttribute("data-active");
+      }
+    }
+    if (state.status === "showQR") {
+      const img = container.querySelector(".eudi-qr-img");
+      if (img && "qrDataUrl" in state) {
+        img.src = state.qrDataUrl;
+      }
+    }
+    if (state.status === "rejected" && "error" in state && state.error) {
+      const detail = container.querySelector(`#${getStateId("rejected")} .eudi-error-detail`);
+      if (detail) {
+        detail.textContent = state.error;
+      }
+    }
+    if (state.status === "error" && "error" in state) {
+      const detail = container.querySelector(`#${getStateId("error")} .eudi-error-detail`);
+      if (detail) {
+        detail.textContent = state.error;
+      }
+    }
+  }
+
+  // src/a11y.ts
+  var FOCUSABLE_SELECTORS = [
+    "button:not([disabled])",
+    '[tabindex]:not([tabindex="-1"])',
+    "a[href]",
+    "input:not([disabled])"
+  ].join(", ");
+  function getFocusableElements(container) {
+    return Array.from(container.querySelectorAll(FOCUSABLE_SELECTORS));
+  }
+  function createFocusTrap(container) {
+    let previouslyFocused = null;
+    function handleKeyDown(event) {
+      if (event.key !== "Tab") return;
+      const focusable = getFocusableElements(container);
+      if (focusable.length === 0) return;
+      const firstElement = focusable[0];
+      const lastElement = focusable[focusable.length - 1];
+      if (event.shiftKey && document.activeElement === firstElement) {
+        event.preventDefault();
+        lastElement.focus();
+      } else if (!event.shiftKey && document.activeElement === lastElement) {
+        event.preventDefault();
+        firstElement.focus();
+      }
+    }
+    function activate() {
+      previouslyFocused = document.activeElement;
+      container.addEventListener("keydown", handleKeyDown);
+      const focusable = getFocusableElements(container);
+      if (focusable.length > 0) {
+        focusable[0].focus();
+      }
+    }
+    function deactivate() {
+      container.removeEventListener("keydown", handleKeyDown);
+      if (previouslyFocused && typeof previouslyFocused.focus === "function") {
+        previouslyFocused.focus();
+      }
+    }
+    activate();
+    return deactivate;
+  }
+  function announce(liveRegion, message, priority = "polite") {
+    liveRegion.setAttribute("aria-live", priority);
+    liveRegion.textContent = "";
+    requestAnimationFrame(() => {
+      liveRegion.textContent = message;
+    });
+  }
+  function clearAnnouncement(liveRegion) {
+    liveRegion.textContent = "";
+  }
+  var STATE_MESSAGES = {
+    idle: "",
+    loading: "Loading verification session...",
+    showQR: "QR code ready. Scan with your EU Digital Identity Wallet.",
+    waitingForWallet: "Waiting for wallet approval...",
+    verified: "Identity verified successfully.",
+    rejected: "Verification was declined.",
+    expired: "Verification session expired.",
+    error: "Verification error occurred."
+  };
+  function getAnnouncementPriority(status) {
+    switch (status) {
+      case "verified":
+      case "rejected":
+      case "expired":
+      case "error":
+        return "assertive";
+      default:
+        return "polite";
+    }
+  }
+
+  // src/element.ts
+  var OBSERVED_ATTRIBUTES = ["api-url", "request", "auto-start"];
+  var EudiVerifyElement = class extends HTMLElement {
+    static get observedAttributes() {
+      return OBSERVED_ATTRIBUTES;
+    }
+    #shadow;
+    #verification = null;
+    #unsubscribe = null;
+    #container = null;
+    #liveRegion = null;
+    #lastStatus = null;
+    #isDemo = null;
+    #demoBanner = null;
+    constructor() {
+      super();
+      this.#shadow = this.attachShadow({ mode: "open" });
+    }
+    /**
+     * Get the API URL attribute.
+     */
+    get apiUrl() {
+      return this.getAttribute("api-url") ?? "";
+    }
+    /**
+     * Set the API URL attribute.
+     */
+    set apiUrl(value) {
+      this.setAttribute("api-url", value);
+    }
+    /**
+     * Get the request attribute (JSON string).
+     */
+    get request() {
+      return this.getAttribute("request") ?? "";
+    }
+    /**
+     * Set the request attribute (JSON string).
+     */
+    set request(value) {
+      this.setAttribute("request", value);
+    }
+    /**
+     * Check if auto-start is enabled.
+     */
+    get autoStart() {
+      return this.hasAttribute("auto-start");
+    }
+    /**
+     * Set auto-start attribute.
+     */
+    set autoStart(value) {
+      if (value) {
+        this.setAttribute("auto-start", "");
+      } else {
+        this.removeAttribute("auto-start");
+      }
+    }
+    /**
+     * Current verification state (read-only).
+     */
+    get state() {
+      return this.#verification?.state ?? null;
+    }
+    connectedCallback() {
+      this.#render();
+      this.#setupEventListeners();
+      if (this.autoStart && this.apiUrl && this.request) {
+        this.start();
+      }
+    }
+    disconnectedCallback() {
+      this.#cleanup();
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+      if (oldValue === newValue) return;
+      if (name === "api-url" && this.#verification) {
+        this.#cleanup();
+      }
+    }
+    /**
+     * Start the verification flow.
+     */
+    start() {
+      if (!this.apiUrl) {
+        console.error("[eudi-verify] api-url attribute is required");
+        return;
+      }
+      let requestObj;
+      try {
+        requestObj = this.request ? JSON.parse(this.request) : {};
+      } catch {
+        console.error("[eudi-verify] Invalid JSON in request attribute");
+        this.#dispatchError("Invalid verification request");
+        return;
+      }
+      this.#ensureVerification();
+      this.#verification.start(requestObj);
+    }
+    /**
+     * Cancel the current verification.
+     */
+    cancel() {
+      this.#verification?.cancel();
+    }
+    /**
+     * Reset to idle state.
+     */
+    reset() {
+      this.#cleanup();
+      this.#updateState({ status: "idle" });
+    }
+    #render() {
+      this.#shadow.innerHTML = `
+      <style>${createStyles()}</style>
+      ${renderWidget()}
+    `;
+      this.#container = this.#shadow.querySelector(".eudi-widget");
+      this.#liveRegion = this.#shadow.querySelector("[aria-live]");
+      this.#demoBanner = this.#shadow.querySelector(".eudi-demo-banner");
+    }
+    #setupEventListeners() {
+      this.#shadow.addEventListener("click", (event) => {
+        const target = event.target;
+        const button = target.closest("[data-action]");
+        if (!button) return;
+        const action = button.dataset.action;
+        switch (action) {
+          case "start":
+            this.start();
+            break;
+          case "cancel":
+            this.cancel();
+            break;
+          case "reset":
+            this.reset();
+            this.start();
+            break;
+        }
+      });
+    }
+    #ensureVerification() {
+      if (this.#verification) return;
+      this.#verification = createVerification({
+        apiUrl: this.apiUrl
+      });
+      this.#unsubscribe = this.#verification.subscribe((state) => {
+        this.#handleStateChange(state);
+      });
+      this.#detectDemoMode();
+    }
+    async #detectDemoMode() {
+      if (this.#isDemo !== null || !this.apiUrl) return;
+      try {
+        const response = await fetch(`${this.apiUrl}/sessions`, {
+          method: "HEAD"
+        });
+        const mode = response.headers.get("X-Eudi-Mode");
+        this.#isDemo = mode === "demo";
+        this.#updateDemoBanner();
+      } catch {
+        this.#isDemo = false;
+      }
+    }
+    #updateDemoBanner() {
+      if (!this.#demoBanner) return;
+      if (this.#isDemo === true) {
+        this.#demoBanner.removeAttribute("hidden");
+      } else {
+        this.#demoBanner.setAttribute("hidden", "");
+      }
+    }
+    #handleStateChange(state) {
+      this.#updateState(state);
+      this.#dispatchStateChange(state);
+      switch (state.status) {
+        case "verified":
+          if ("token" in state && "claims" in state) {
+            this.#dispatchVerified(state.token, state.claims);
+          }
+          break;
+        case "rejected":
+          this.#dispatchRejected("error" in state ? state.error : void 0);
+          break;
+        case "expired":
+          this.#dispatchExpired();
+          break;
+        case "error":
+          if ("error" in state) {
+            this.#dispatchError(state.error);
+          }
+          break;
+      }
+    }
+    #updateState(state) {
+      if (!this.#container) return;
+      updateWidgetState(this.#container, state);
+      if (this.#liveRegion && state.status !== this.#lastStatus) {
+        const message = STATE_MESSAGES[state.status];
+        if (message) {
+          const priority = getAnnouncementPriority(state.status);
+          announce(this.#liveRegion, message, priority);
+        }
+      }
+      this.#lastStatus = state.status;
+      this.#manageFocus(state);
+    }
+    #manageFocus(state) {
+      if (!this.#container) return;
+      switch (state.status) {
+        case "showQR": {
+          const cancelBtn = this.#container.querySelector("#eudi-state-showQR .eudi-cancel-btn");
+          cancelBtn?.focus();
+          break;
+        }
+        case "verified":
+        case "rejected":
+        case "expired":
+        case "error": {
+          const retryBtn = this.#container.querySelector(
+            `#eudi-state-${state.status} .eudi-retry-btn`
+          );
+          retryBtn?.focus();
+          break;
+        }
+      }
+    }
+    #dispatchVerified(token, claims) {
+      this.dispatchEvent(
+        new CustomEvent("verified", {
+          bubbles: true,
+          composed: true,
+          detail: { token, claims }
+        })
+      );
+    }
+    #dispatchRejected(error) {
+      this.dispatchEvent(
+        new CustomEvent("rejected", {
+          bubbles: true,
+          composed: true,
+          detail: { error }
+        })
+      );
+    }
+    #dispatchExpired() {
+      this.dispatchEvent(
+        new CustomEvent("expired", {
+          bubbles: true,
+          composed: true,
+          detail: {}
+        })
+      );
+    }
+    #dispatchError(error) {
+      this.dispatchEvent(
+        new CustomEvent("error", {
+          bubbles: true,
+          composed: true,
+          detail: { error }
+        })
+      );
+    }
+    #dispatchStateChange(state) {
+      this.dispatchEvent(
+        new CustomEvent("state-change", {
+          bubbles: true,
+          composed: true,
+          detail: { state }
+        })
+      );
+    }
+    #cleanup() {
+      if (this.#unsubscribe) {
+        this.#unsubscribe();
+        this.#unsubscribe = null;
+      }
+      if (this.#verification) {
+        this.#verification.destroy();
+        this.#verification = null;
+      }
+      if (this.#liveRegion) {
+        clearAnnouncement(this.#liveRegion);
+      }
+      this.#lastStatus = null;
+    }
+  };
+
+  // src/index.ts
+  var VERSION = "0.1.0";
+  if (typeof customElements !== "undefined" && !customElements.get("eudi-verify")) {
+    customElements.define("eudi-verify", EudiVerifyElement);
+  }
+  return __toCommonJS(src_exports);
+})();
+//# sourceMappingURL=eudi-verify.iife.js.map