@lodashventure/medusa-login-provider 0.4.10 → 0.4.12

package/.medusa/server/src/providers/line/redis-helper.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineRedisHelper = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class LineRedisHelper {
+    constructor(redisUrl, logger) {
+        this.PREFIX = "line:pending_customer:";
+        this.TTL_SECONDS = 86400; // 24 hours
+        this.redis = new ioredis_1.default(redisUrl);
+        this.logger = logger;
+    }
+    /**
+     * Store pending customer data in Redis with TTL
+     * Uses auth_identity_id as the key for easy retrieval
+     */
+    async storePendingCustomer(authIdentityId, data) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        const pendingData = {
+            ...data,
+            created_at: new Date().toISOString(),
+            expires_at: new Date(Date.now() + this.TTL_SECONDS * 1000).toISOString(),
+        };
+        try {
+            await this.redis.setex(key, this.TTL_SECONDS, JSON.stringify(pendingData));
+            this.logger.info(`Stored pending customer in Redis: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to store pending customer in Redis: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Retrieve pending customer data from Redis by auth_identity_id
+     */
+    async getPendingCustomer(authIdentityId) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            const data = await this.redis.get(key);
+            if (!data) {
+                return null;
+            }
+            return JSON.parse(data);
+        }
+        catch (error) {
+            this.logger.error(`Failed to get pending customer from Redis: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Delete pending customer data from Redis (after successful creation)
+     */
+    async deletePendingCustomer(authIdentityId) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            await this.redis.del(key);
+            this.logger.info(`Deleted pending customer from Redis: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to delete pending customer from Redis: ${error}`);
+        }
+    }
+    /**
+     * Get all pending customers (for admin monitoring)
+     */
+    async getAllPendingCustomers() {
+        try {
+            const pattern = `${this.PREFIX}*`;
+            const keys = await this.redis.keys(pattern);
+            if (keys.length === 0) {
+                return [];
+            }
+            const pipeline = this.redis.pipeline();
+            keys.forEach(key => pipeline.get(key));
+            const results = await pipeline.exec();
+            const pendingCustomers = [];
+            results?.forEach(([err, data]) => {
+                if (!err && data) {
+                    try {
+                        pendingCustomers.push(JSON.parse(data));
+                    }
+                    catch (parseError) {
+                        this.logger.error(`Failed to parse pending customer data: ${parseError}`);
+                    }
+                }
+            });
+            return pendingCustomers;
+        }
+        catch (error) {
+            this.logger.error(`Failed to get all pending customers from Redis: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Check if customer data exists in Redis
+     */
+    async hasPendingCustomer(authIdentityId) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            const exists = await this.redis.exists(key);
+            return exists === 1;
+        }
+        catch (error) {
+            this.logger.error(`Failed to check pending customer in Redis: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Update TTL for pending customer
+     */
+    async extendTTL(authIdentityId, additionalSeconds = 86400) {
+        const key = `${this.PREFIX}${authIdentityId}`;
+        try {
+            const result = await this.redis.expire(key, this.TTL_SECONDS + additionalSeconds);
+            return result === 1;
+        }
+        catch (error) {
+            this.logger.error(`Failed to extend TTL for pending customer: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Close Redis connection
+     */
+    async disconnect() {
+        await this.redis.quit();
+    }
+}
+exports.LineRedisHelper = LineRedisHelper;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/line/service.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const crypto_1 = __importDefault(require("crypto"));
+const redis_helper_1 = require("./redis-helper");
+class LineProviderService extends utils_1.AbstractAuthModuleProvider {
+    constructor(dependencies, options) {
+        super();
+        this.LINE_TOKEN_ENDPOINT = "https://api.line.me/oauth2/v2.1/token";
+        this.LINE_PROFILE_ENDPOINT = "https://api.line.me/v2/profile";
+        this.logger_ = dependencies.logger;
+        this.options_ = {
+            autoCreateCustomer: true,
+            syncProfileData: true,
+            storeUnlinkedInRedis: true,
+            ...options,
+        };
+        // Initialize Redis helper if Redis URL is provided
+        if (this.options_.redisUrl && this.options_.storeUnlinkedInRedis) {
+            this.redisHelper = new redis_helper_1.LineRedisHelper(this.options_.redisUrl, this.logger_);
+        }
+    }
+    static validateOptions(options) {
+        if (!options.lineChannelId) {
+            throw new Error("line channel id is required");
+        }
+        if (!options.lineChannelSecret) {
+            throw new Error("line channel secret is required");
+        }
+    }
+    async register(_data, _authIdentityService) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Line does not support registration. Use method `authenticate` instead.");
+    }
+    async authenticate(data, authIdentityService) {
+        const query = data.query ?? {};
+        const body = data.body ?? {};
+        if (query.error) {
+            return {
+                success: false,
+                error: `${query.error_description}, read more at: ${query.error_uri}`,
+            };
+        }
+        const stateKey = crypto_1.default.randomBytes(32).toString("hex");
+        // Use Medusa's native callback URL pattern
+        const baseUrl = body?.callback_url;
+        const state = {
+            callback_url: baseUrl,
+        };
+        await authIdentityService.setState(stateKey, state);
+        return this.getRedirect(this.options_.lineChannelId, baseUrl, stateKey);
+    }
+    async validateCallback(req, authIdentityService) {
+        const query = req.query ?? {};
+        const body = req.body ?? {};
+        if (query.error) {
+            this.logger_.error(`LINE OAuth error: ${query.error} - ${query.error_description} - ${query.error_uri} - state: ${query.state}`);
+            return {
+                success: false,
+                error: `${query.error_description}, read more at: ${query.error_uri}`,
+            };
+        }
+        const code = query?.code ?? body?.code;
+        if (!code) {
+            this.logger_.error(`LINE callback validation failed: No authorization code provided - query: ${JSON.stringify(query)} - body: ${JSON.stringify(body)}`);
+            return { success: false, error: "No authorization code provided" };
+        }
+        const stateKey = query?.state ?? body?.state;
+        if (!stateKey) {
+            this.logger_.error(`LINE callback validation failed: No state parameter provided - code: ${code ? "present" : "missing"}`);
+            return { success: false, error: "No state parameter provided" };
+        }
+        const state = await authIdentityService.getState(stateKey);
+        if (!state) {
+            this.logger_.error(`LINE callback validation failed: Invalid state or session expired - stateKey: ${stateKey}`);
+            return { success: false, error: "Invalid state or session expired" };
+        }
+        try {
+            this.logger_.info(`Starting LINE token exchange - hasCode: ${!!code}, hasState: ${!!stateKey}`);
+            const tokenResponse = await this.exchangeCodeForTokens(code, state.callback_url);
+            this.logger_.info("LINE token exchange successful, verifying ID token");
+            const idTokenPayload = await this.verifyIdToken(tokenResponse.id_token);
+            this.logger_.info("ID token verified, fetching user profile");
+            const profile = await this.fetchUserProfile(tokenResponse.access_token);
+            this.logger_.info(`LINE user profile fetched successfully - userId: ${profile.userId}, displayName: ${profile.displayName}, hasEmail: ${!!idTokenPayload.email}`);
+            const { authIdentity } = await this.findOrCreateAuthIdentity(idTokenPayload, profile, tokenResponse, authIdentityService);
+            // Store in Redis using auth_identity_id as key for easy retrieval
+            if (this.redisHelper && !authIdentity.app_metadata?.customer_id) {
+                await this.redisHelper.storePendingCustomer(authIdentity.id, {
+                    line_user_id: profile.userId,
+                    email: idTokenPayload.email,
+                    display_name: profile.displayName,
+                    picture_url: profile.pictureUrl,
+                    status_message: profile.statusMessage,
+                    name: idTokenPayload.name,
+                    auth_identity_id: authIdentity.id,
+                });
+                this.logger_.info(`Stored pending customer in Redis with auth_id: ${authIdentity.id}`);
+            }
+            return {
+                success: true,
+                authIdentity,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            this.logger_.error(`LINE callback validation failed: ${errorMessage} - code: ${code ? "present" : "missing"}, state: ${stateKey ? "present" : "missing"}, stack: ${errorStack}`);
+            return { success: false, error: errorMessage };
+        }
+    }
+    async exchangeCodeForTokens(code, redirectUri) {
+        const response = await fetch(this.LINE_TOKEN_ENDPOINT, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: new URLSearchParams({
+                grant_type: "authorization_code",
+                code: code,
+                client_id: this.options_.lineChannelId,
+                client_secret: this.options_.lineChannelSecret,
+                redirect_uri: redirectUri,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.text();
+            this.logger_.error(`LINE token exchange failed - status: ${response.status}, statusText: ${response.statusText}, errorData: ${errorData}, clientId: ${this.options_.lineChannelId}`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to exchange authorization code: ${response.status} ${errorData}`);
+        }
+        return response.json();
+    }
+    async verifyIdToken(idToken) {
+        const decoded = jsonwebtoken_1.default.decode(idToken, { complete: true });
+        if (!decoded) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Failed to decode ID token");
+        }
+        const payload = decoded.payload;
+        if (payload.aud !== this.options_.lineChannelId) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token audience mismatch");
+        }
+        if (payload.iss !== "https://access.line.me") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token issuer mismatch");
+        }
+        const now = Math.floor(Date.now() / 1000);
+        if (payload.exp < now) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "ID token has expired");
+        }
+        return payload;
+    }
+    async fetchUserProfile(accessToken) {
+        const response = await fetch(this.LINE_PROFILE_ENDPOINT, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (!response.ok) {
+            const errorData = await response.text();
+            this.logger_.error(`Failed to fetch LINE profile - status: ${response.status}, statusText: ${response.statusText}, errorData: ${errorData}`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to fetch LINE profile: ${response.status} ${errorData}`);
+        }
+        return response.json();
+    }
+    async findOrCreateAuthIdentity(idTokenPayload, profile, tokenResponse, authIdentityService) {
+        const entity_id = profile.userId;
+        const userMetadata = {
+            // New format for consistency
+            userId: profile.userId,
+            displayName: profile.displayName,
+            pictureUrl: profile.pictureUrl,
+            // Legacy format for backwards compatibility
+            line_user_id: profile.userId,
+            display_name: profile.displayName,
+            picture_url: profile.pictureUrl,
+            status_message: profile.statusMessage,
+            email: idTokenPayload.email,
+            name: idTokenPayload.name || profile.displayName,
+            picture: idTokenPayload.picture || profile.pictureUrl,
+            first_name: (idTokenPayload.name || profile.displayName || "").split(" ")[0] ||
+                profile.displayName,
+            last_name: (idTokenPayload.name || profile.displayName || "")
+                .split(" ")
+                .slice(1)
+                .join(" ") || "",
+            needs_customer_creation: this.options_.autoCreateCustomer,
+        };
+        // Store tokens in provider metadata for potential later use
+        const providerMetadata = {
+            access_token: tokenResponse.access_token,
+            refresh_token: tokenResponse.refresh_token,
+            expires_in: tokenResponse.expires_in,
+            token_type: tokenResponse.token_type,
+            scope: tokenResponse.scope,
+        };
+        let authIdentity;
+        try {
+            authIdentity = await authIdentityService.retrieve({ entity_id });
+            authIdentity = await authIdentityService.update(entity_id, {
+                user_metadata: userMetadata,
+                provider_metadata: providerMetadata,
+            });
+        }
+        catch (error) {
+            if (error.type === utils_1.MedusaError.Types.NOT_FOUND) {
+                this.logger_.info(`Creating new auth identity for LINE user - entity_id: ${entity_id}, displayName: ${userMetadata.display_name}, email: ${userMetadata.email || `line_${entity_id}@line.me`}`);
+                authIdentity = await authIdentityService.create({
+                    entity_id,
+                    user_metadata: userMetadata,
+                    provider_metadata: providerMetadata,
+                });
+                this.logger_.info(`Auth identity created successfully - authIdentityId: ${authIdentity.id}, entity_id: ${entity_id}`);
+            }
+            else {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger_.error(`Failed to find or create auth identity - error: ${errorMessage}, entity_id: ${entity_id}`);
+                throw error;
+            }
+        }
+        return { authIdentity };
+    }
+    async refreshToken(refreshToken) {
+        try {
+            const response = await fetch(this.LINE_TOKEN_ENDPOINT, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    grant_type: "refresh_token",
+                    refresh_token: refreshToken,
+                    client_id: this.options_.lineChannelId,
+                    client_secret: this.options_.lineChannelSecret,
+                }),
+            });
+            if (!response.ok) {
+                this.logger_.error(`Failed to refresh LINE token: ${response.status}`);
+                return null;
+            }
+            return response.json();
+        }
+        catch (error) {
+            this.logger_.error("Error refreshing LINE token:", error);
+            return null;
+        }
+    }
+    async revokeToken(accessToken) {
+        try {
+            const response = await fetch("https://api.line.me/oauth2/v2.1/revoke", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    access_token: accessToken,
+                    client_id: this.options_.lineChannelId,
+                    client_secret: this.options_.lineChannelSecret,
+                }),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            this.logger_.error("Error revoking LINE token:", error);
+            return false;
+        }
+    }
+    getRedirect(clientId, callbackUrl, stateKey) {
+        const nonce = crypto_1.default.randomBytes(16).toString("hex");
+        const authUrl = new URL(`https://access.line.me/oauth2/v2.1/authorize`);
+        authUrl.searchParams.set("response_type", "code");
+        authUrl.searchParams.set("scope", "profile openid email");
+        authUrl.searchParams.set("client_id", clientId);
+        authUrl.searchParams.set("redirect_uri", callbackUrl);
+        authUrl.searchParams.set("state", stateKey);
+        authUrl.searchParams.set("nonce", nonce);
+        return { success: true, location: authUrl.toString() };
+    }
+}
+LineProviderService.identifier = "line";
+LineProviderService.DISPLAY_NAME = "LINE";
+exports.default = LineProviderService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/providers/line/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/providers/line/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2xpbmUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/.medusa/server/src/providers/line/utils.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+exports.generateState = generateState;
+exports.generateNonce = generateNonce;
+exports.generatePlaceholderEmail = generatePlaceholderEmail;
+exports.parseDisplayName = parseDisplayName;
+exports.validateChannelId = validateChannelId;
+exports.validateCallbackUrl = validateCallbackUrl;
+exports.sanitizeInput = sanitizeInput;
+exports.createAuditLog = createAuditLog;
+exports.handleLineApiError = handleLineApiError;
+const crypto_1 = __importDefault(require("crypto"));
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Generates a secure state parameter for OAuth flow
+ */
+function generateState() {
+    return crypto_1.default.randomBytes(32).toString("hex");
+}
+/**
+ * Generates a nonce for ID token validation
+ */
+function generateNonce() {
+    return crypto_1.default.randomBytes(16).toString("hex");
+}
+/**
+ * Creates a placeholder email for LINE users without email
+ */
+function generatePlaceholderEmail(lineUserId, domain = "line.local") {
+    return `line-${lineUserId}@${domain}`;
+}
+/**
+ * Extracts first and last name from display name
+ */
+function parseDisplayName(displayName) {
+    const parts = displayName.trim().split(" ");
+    const firstName = parts[0] || "";
+    const lastName = parts.slice(1).join(" ") || "";
+    return { firstName, lastName };
+}
+/**
+ * Validates LINE Channel ID format
+ */
+function validateChannelId(channelId) {
+    return /^\d{10}$/.test(channelId);
+}
+/**
+ * Validates callback URL
+ */
+function validateCallbackUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "https:" || parsed.hostname === "localhost";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Rate limit tracker for API calls
+ */
+class RateLimiter {
+    constructor(maxAttempts = 10, windowMs = 60000) {
+        this.attempts = new Map();
+        this.maxAttempts = maxAttempts;
+        this.windowMs = windowMs;
+    }
+    isAllowed(key) {
+        const now = Date.now();
+        const attempts = this.attempts.get(key) || [];
+        // Remove expired attempts
+        const validAttempts = attempts.filter((timestamp) => now - timestamp < this.windowMs);
+        if (validAttempts.length >= this.maxAttempts) {
+            return false;
+        }
+        validAttempts.push(now);
+        this.attempts.set(key, validAttempts);
+        return true;
+    }
+    reset(key) {
+        this.attempts.delete(key);
+    }
+}
+exports.RateLimiter = RateLimiter;
+/**
+ * Sanitizes user input to prevent injection attacks
+ */
+function sanitizeInput(input) {
+    return input
+        .replace(/[<>]/g, "")
+        .replace(/javascript:/gi, "")
+        .trim();
+}
+function createAuditLog(entry) {
+    return {
+        ...entry,
+        timestamp: new Date(),
+    };
+}
+/**
+ * Handles LINE API errors
+ */
+function handleLineApiError(status, message) {
+    const errorMessages = {
+        400: "Invalid request to LINE API",
+        401: "LINE authentication failed",
+        403: "Access forbidden by LINE",
+        429: "Too many requests to LINE API",
+        500: "LINE server error",
+        503: "LINE service temporarily unavailable",
+    };
+    const errorMessage = errorMessages[status] || `LINE API error: ${status}`;
+    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `${errorMessage}: ${message}`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2xpbmUvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBTUEsc0NBRUM7QUFLRCxzQ0FFQztBQUtELDREQUVDO0FBS0QsNENBUUM7QUFLRCw4Q0FFQztBQUtELGtEQU9DO0FBMENELHNDQUtDO0FBZUQsd0NBS0M7QUFLRCxnREFnQkM7QUE5SUQsb0RBQTRCO0FBQzVCLHFEQUF3RDtBQUV4RDs7R0FFRztBQUNILFNBQWdCLGFBQWE7SUFDM0IsT0FBTyxnQkFBTSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDaEQsQ0FBQztBQUVEOztHQUVHO0FBQ0gsU0FBZ0IsYUFBYTtJQUMzQixPQUFPLGdCQUFNLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNoRCxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxTQUFnQix3QkFBd0IsQ0FBQyxVQUFrQixFQUFFLE1BQU0sR0FBRyxZQUFZO0lBQ2hGLE9BQU8sUUFBUSxVQUFVLElBQUksTUFBTSxFQUFFLENBQUM7QUFDeEMsQ0FBQztBQUVEOztHQUVHO0FBQ0gsU0FBZ0IsZ0JBQWdCLENBQUMsV0FBbUI7SUFJbEQsTUFBTSxLQUFLLEdBQUcsV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUM1QyxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2pDLE1BQU0sUUFBUSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNoRCxPQUFPLEVBQUUsU0FBUyxFQUFFLFFBQVEsRUFBRSxDQUFDO0FBQ2pDLENBQUM7QUFFRDs7R0FFRztBQUNILFNBQWdCLGlCQUFpQixDQUFDLFNBQWlCO0lBQ2pELE9BQU8sVUFBVSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUNwQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxTQUFnQixtQkFBbUIsQ0FBQyxHQUFXO0lBQzdDLElBQUksQ0FBQztRQUNILE1BQU0sTUFBTSxHQUFHLElBQUksR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzVCLE9BQU8sTUFBTSxDQUFDLFFBQVEsS0FBSyxRQUFRLElBQUksTUFBTSxDQUFDLFFBQVEsS0FBSyxXQUFXLENBQUM7SUFDekUsQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztBQUNILENBQUM7QUFFRDs7R0FFRztBQUNILE1BQWEsV0FBVztJQUt0QixZQUFZLFdBQVcsR0FBRyxFQUFFLEVBQUUsUUFBUSxHQUFHLEtBQUs7UUFKdEMsYUFBUSxHQUEwQixJQUFJLEdBQUcsRUFBRSxDQUFDO1FBS2xELElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO0lBQzNCLENBQUM7SUFFRCxTQUFTLENBQUMsR0FBVztRQUNuQixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDdkIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDO1FBRTlDLDBCQUEwQjtRQUMxQixNQUFNLGFBQWEsR0FBRyxRQUFRLENBQUMsTUFBTSxDQUNuQyxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLFNBQVMsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUMvQyxDQUFDO1FBRUYsSUFBSSxhQUFhLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUM3QyxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7UUFFRCxhQUFhLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxhQUFhLENBQUMsQ0FBQztRQUV0QyxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCxLQUFLLENBQUMsR0FBVztRQUNmLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzVCLENBQUM7Q0FDRjtBQWhDRCxrQ0FnQ0M7QUFFRDs7R0FFRztBQUNILFNBQWdCLGFBQWEsQ0FBQyxLQUFhO0lBQ3pDLE9BQU8sS0FBSztTQUNULE9BQU8sQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDO1NBQ3BCLE9BQU8sQ0FBQyxlQUFlLEVBQUUsRUFBRSxDQUFDO1NBQzVCLElBQUksRUFBRSxDQUFDO0FBQ1osQ0FBQztBQWVELFNBQWdCLGNBQWMsQ0FBQyxLQUF1QztJQUNwRSxPQUFPO1FBQ0wsR0FBRyxLQUFLO1FBQ1IsU0FBUyxFQUFFLElBQUksSUFBSSxFQUFFO0tBQ3RCLENBQUM7QUFDSixDQUFDO0FBRUQ7O0dBRUc7QUFDSCxTQUFnQixrQkFBa0IsQ0FBQyxNQUFjLEVBQUUsT0FBZTtJQUNoRSxNQUFNLGFBQWEsR0FBMkI7UUFDNUMsR0FBRyxFQUFFLDZCQUE2QjtRQUNsQyxHQUFHLEVBQUUsNEJBQTRCO1FBQ2pDLEdBQUcsRUFBRSwwQkFBMEI7UUFDL0IsR0FBRyxFQUFFLCtCQUErQjtRQUNwQyxHQUFHLEVBQUUsbUJBQW1CO1FBQ3hCLEdBQUcsRUFBRSxzQ0FBc0M7S0FDNUMsQ0FBQztJQUVGLE1BQU0sWUFBWSxHQUFHLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxtQkFBbUIsTUFBTSxFQUFFLENBQUM7SUFFMUUsTUFBTSxJQUFJLG1CQUFXLENBQ25CLG1CQUFXLENBQUMsS0FBSyxDQUFDLFlBQVksRUFDOUIsR0FBRyxZQUFZLEtBQUssT0FBTyxFQUFFLENBQzlCLENBQUM7QUFDSixDQUFDIn0=