fraim 2.0.179 → 2.0.180

package/dist/src/middleware/cors-config.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCorsOptions = buildCorsOptions;
+exports.resolveSseAllowedOrigin = resolveSseAllowedOrigin;
+const git_utils_1 = require("../core/utils/git-utils");
+/**
+ * CORS allowlist configuration for the FRAIM server.
+ *
+ * Lives in its own module (not src/fraim-mcp-server.ts) so tests can import
+ * `buildCorsOptions` and `resolveSseAllowedOrigin` without running the
+ * top-level server bootstrap as a side effect.
+ *
+ * Allowlist sources (merged):
+ *   - FRAIM_CORS_ALLOWED_ORIGINS (comma-separated absolute origins, e.g.
+ *     "https://app.example.com,https://staging.example.com")
+ *   - Built-in production origins for fraimworks.ai
+ *   - Localhost dev origins when NODE_ENV !== 'production'
+ *
+ * Requests without an Origin header are allowed for curl/server-to-server
+ * callers. Browser POST/fetch requests can still include Origin on same-origin
+ * requests, so the active local FRAIM port must be allowlisted in development.
+ */
+function buildAllowlist() {
+    const fromEnv = (process.env.FRAIM_CORS_ALLOWED_ORIGINS || '')
+        .split(',')
+        .map(o => o.trim())
+        .filter(Boolean);
+    const publicBaseUrl = (process.env.FRAIM_PUBLIC_BASE_URL || '').replace(/\/+$/, '').trim();
+    const allowed = new Set([
+        ...fromEnv,
+        'https://fraimworks.ai',
+        'https://www.fraimworks.ai',
+        'https://fraim.wellnessatwork.me',
+        // Claude surfaces — browser-originated requests from claude.ai web app,
+        // Claude Design, and claude.ai settings pages (Connectors setup flow).
+        // Anthropic's backend MCP calls have no Origin header so don't need listing.
+        'https://claude.ai',
+        'https://www.claude.ai',
+        'https://design.claude.ai',
+        'https://api.anthropic.com',
+    ]);
+    if (publicBaseUrl && /^https?:\/\//i.test(publicBaseUrl)) {
+        allowed.add(publicBaseUrl);
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        const localPorts = new Set([3000, 3002, 8080, 8765]);
+        const addPort = (value) => {
+            if (!value)
+                return;
+            const parsed = Number(value);
+            if (Number.isInteger(parsed) && parsed > 0) {
+                localPorts.add(parsed);
+            }
+        };
+        addPort(String((0, git_utils_1.getPort)()));
+        addPort(process.env.FRAIM_MCP_PORT);
+        addPort(process.env.PORT);
+        addPort(process.env.WEBSITES_PORT);
+        addPort(process.env.PLAYWRIGHT_FRAIM_MCP_PORT);
+        addPort(process.env.PLAYWRIGHT_WEBSITE_PORT);
+        const playwrightBaseUrl = (process.env.PLAYWRIGHT_BASE_URL || '').trim();
+        if (playwrightBaseUrl) {
+            try {
+                const parsed = new URL(playwrightBaseUrl);
+                if (parsed.protocol === 'http:' || parsed.protocol === 'https:') {
+                    allowed.add(parsed.origin);
+                }
+            }
+            catch {
+                // Ignore invalid PLAYWRIGHT_BASE_URL values and fall back to the static allowlist.
+            }
+        }
+        for (const localPort of localPorts) {
+            allowed.add(`http://localhost:${localPort}`);
+            allowed.add(`http://127.0.0.1:${localPort}`);
+        }
+    }
+    return allowed;
+}
+function buildCorsOptions() {
+    const allowed = buildAllowlist();
+    return {
+        origin: (origin, callback) => {
+            // Same-origin and non-browser tools have no Origin header.
+            // This covers Anthropic's cloud infrastructure making server-to-server
+            // MCP calls on behalf of claude.ai Connectors — no Origin header present.
+            if (!origin)
+                return callback(null, true);
+            if (allowed.has(origin))
+                return callback(null, true);
+            return callback(new Error(`CORS: origin ${origin} is not in the allowlist`));
+        },
+        credentials: false,
+        methods: ['GET', 'POST', 'OPTIONS'],
+        // Authorization: required by MCP HTTP transport for Bearer token auth
+        // mcp-session-id: required by MCP Streamable HTTP spec for session tracking
+        allowedHeaders: ['Content-Type', 'x-api-key', 'x-admin-key', 'x-fraim-auth-mode', 'x-fraim-local-version', 'x-fraim-session-id', 'Authorization', 'mcp-session-id'],
+        exposedHeaders: ['mcp-session-id'],
+    };
+}
+/**
+ * Resolve the SSE Access-Control-Allow-Origin value against the allowlist.
+ * Returns the request's Origin if it is allowed, otherwise undefined so the
+ * caller can omit the header entirely. Never returns the wildcard '*'.
+ */
+function resolveSseAllowedOrigin(origin) {
+    if (!origin)
+        return undefined;
+    const allowed = buildAllowlist();
+    return allowed.has(origin) ? origin : undefined;
+}

package/dist/src/middleware/logger.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLogger = requestLogger;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LOG_FILE = path.join(process.cwd(), 'server-direct.log');
+/**
+ * Extracts API key from request for logging purposes
+ */
+function getApiKeyForLogging(req) {
+    const fromContext = req.apiKeyData?.key;
+    if (typeof fromContext === 'string' && fromContext.trim().length > 0) {
+        return fromContext;
+    }
+    const fromHeader = Array.isArray(req.headers['x-api-key'])
+        ? req.headers['x-api-key'][0]
+        : req.headers['x-api-key'];
+    if (typeof fromHeader === 'string' && fromHeader.trim().length > 0) {
+        return fromHeader;
+    }
+    const fromQuery = req.query?.['api-key'];
+    if (typeof fromQuery === 'string' && fromQuery.trim().length > 0) {
+        return fromQuery;
+    }
+    return 'ANONYMOUS';
+}
+/**
+ * Middleware to log all requests
+ */
+function requestLogger(req, res, next) {
+    const start = Date.now();
+    const { method, path } = req;
+    const requestIdHeader = Array.isArray(req.headers['x-fraim-request-id'])
+        ? req.headers['x-fraim-request-id'][0]
+        : req.headers['x-fraim-request-id'];
+    const requestId = typeof requestIdHeader === 'string' && requestIdHeader.trim().length > 0
+        ? requestIdHeader
+        : (0, crypto_1.randomUUID)();
+    const localVersionHeader = Array.isArray(req.headers['x-fraim-local-version'])
+        ? req.headers['x-fraim-local-version'][0]
+        : req.headers['x-fraim-local-version'];
+    const localMcpVersion = typeof localVersionHeader === 'string' && localVersionHeader.trim().length > 0
+        ? localVersionHeader
+        : 'unknown';
+    req.requestId = requestId;
+    req.localMcpVersion = localMcpVersion;
+    res.setHeader('X-FRAIM-Request-ID', requestId);
+    let params = '';
+    if (method === 'POST') {
+        try {
+            params = JSON.stringify(req.body);
+        }
+        catch (e) {
+            params = '[Unserializable Body]';
+        }
+    }
+    const logEntry = (msg) => {
+        const timestamp = new Date().toISOString();
+        const entry = `[${timestamp}] ${msg}\n`;
+        try {
+            fs.appendFileSync(LOG_FILE, entry);
+        }
+        catch (e) {
+            console.error('Failed to write to log file:', e);
+        }
+        if (msg.includes('END') && msg.includes(' 400')) {
+            console.error(msg); // Still log errors to console
+        }
+        else {
+            console.info(msg);
+        }
+    };
+    logEntry(`[req:${requestId}] START ${method} ${path}${params ? ' ' + params : ''}`);
+    res.on('finish', () => {
+        const duration = Date.now() - start;
+        const status = res.statusCode;
+        const keyStr = getApiKeyForLogging(req);
+        const logMsg = `[req:${requestId}] [local:${localMcpVersion}] ${keyStr} END ${method} ${path} ${status} ${duration}ms`;
+        logEntry(logMsg);
+    });
+    next();
+}

package/dist/src/middleware/rate-limit.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sensitiveRateLimiter = exports.publicApiRateLimiter = void 0;
+exports.createRateLimiter = createRateLimiter;
+function createRateLimiter(options) {
+    const { windowMs, max, name } = options;
+    const buckets = new Map();
+    function cleanupExpired(now = Date.now()) {
+        let removed = 0;
+        for (const [key, bucket] of buckets) {
+            if (bucket.resetAt <= now) {
+                buckets.delete(key);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+    // Periodically sweep expired buckets so long-lived processes do not leak memory
+    // proportional to lifetime client-IP cardinality. unref() so the timer never holds
+    // the event loop open during shutdown.
+    let sweepTimer = null;
+    if (process.env.NODE_ENV !== 'test' || process.env.FRAIM_RATE_LIMIT_SWEEP === '1') {
+        sweepTimer = setInterval(() => {
+            const removed = cleanupExpired();
+            if (removed > 0) {
+                console.log(`[FRAIM RATE-LIMIT] ${name} swept ${removed} expired buckets (remaining=${buckets.size})`);
+            }
+        }, windowMs);
+        sweepTimer.unref();
+    }
+    const middleware = function rateLimitMiddleware(req, res, next) {
+        // Rate limits are skipped in test mode so the suite can run hundreds of requests
+        // against the same endpoint quickly. Production and dev still enforce them.
+        if (process.env.NODE_ENV === 'test' && process.env.FRAIM_TEST_RATE_LIMIT !== '1') {
+            return next();
+        }
+        const key = identifyClient(req);
+        const now = Date.now();
+        const bucket = buckets.get(key);
+        if (!bucket || bucket.resetAt <= now) {
+            buckets.set(key, { count: 1, resetAt: now + windowMs });
+            res.setHeader('X-RateLimit-Limit', String(max));
+            res.setHeader('X-RateLimit-Remaining', String(max - 1));
+            res.setHeader('X-RateLimit-Reset', String(Math.ceil((now + windowMs) / 1000)));
+            return next();
+        }
+        if (bucket.count >= max) {
+            const retryAfterSec = Math.max(1, Math.ceil((bucket.resetAt - now) / 1000));
+            res.setHeader('Retry-After', String(retryAfterSec));
+            res.setHeader('X-RateLimit-Limit', String(max));
+            res.setHeader('X-RateLimit-Remaining', '0');
+            res.setHeader('X-RateLimit-Reset', String(Math.ceil(bucket.resetAt / 1000)));
+            console.warn(`[FRAIM RATE-LIMIT] ${name} blocked ${key} on ${req.method} ${req.path}`);
+            return res.status(429).json({
+                error: 'Too many requests',
+                message: `Rate limit exceeded. Try again in ${retryAfterSec} seconds.`
+            });
+        }
+        bucket.count += 1;
+        res.setHeader('X-RateLimit-Limit', String(max));
+        res.setHeader('X-RateLimit-Remaining', String(max - bucket.count));
+        res.setHeader('X-RateLimit-Reset', String(Math.ceil(bucket.resetAt / 1000)));
+        return next();
+    };
+    middleware.reset = () => buckets.clear();
+    middleware.cleanupExpired = cleanupExpired;
+    middleware.stopCleanup = () => {
+        if (sweepTimer) {
+            clearInterval(sweepTimer);
+            sweepTimer = null;
+        }
+    };
+    Object.defineProperty(middleware, 'bucketCount', {
+        get: () => buckets.size
+    });
+    return middleware;
+}
+/**
+ * Identify the client for rate-limit bucketing.
+ * Order: explicit Express-resolved req.ip → first X-Forwarded-For hop → socket address → 'unknown'.
+ */
+function identifyClient(req) {
+    if (req.ip)
+        return req.ip;
+    const xff = req.headers['x-forwarded-for'];
+    if (typeof xff === 'string' && xff.length > 0) {
+        const first = xff.split(',')[0].trim();
+        if (first)
+            return first;
+    }
+    else if (Array.isArray(xff) && xff.length > 0) {
+        const first = xff[0].split(',')[0].trim();
+        if (first)
+            return first;
+    }
+    return req.socket?.remoteAddress || 'unknown';
+}
+/**
+ * Standard public-API limiter: 60 requests per minute per IP.
+ * Suitable for read-only public endpoints (pricing config, session details).
+ */
+const publicApiRateLimiter = () => createRateLimiter({ windowMs: 60_000, max: 60, name: 'public-api' });
+exports.publicApiRateLimiter = publicApiRateLimiter;
+/**
+ * Sensitive-action limiter: 10 requests per minute per IP.
+ * Suitable for signup, contact, bypass, key-retrieval, and other endpoints
+ * whose abuse has direct cost or fraud impact.
+ */
+const sensitiveRateLimiter = () => createRateLimiter({ windowMs: 60_000, max: 10, name: 'sensitive' });
+exports.sensitiveRateLimiter = sensitiveRateLimiter;

package/dist/src/middleware/reject-query-api-key.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rejectQueryStringApiKey = rejectQueryStringApiKey;
+/**
+ * Reject any API/MCP/admin request that carries an api-key in the query string.
+ *
+ * Why this exists separately from the AuthMiddleware's same check:
+ *   The AuthMiddleware short-circuits on public prefixes (e.g. /api/pricing/config),
+ *   which means a request like `/api/pricing/config?api-key=secret` previously slipped
+ *   the credential into URLs and access logs even though the route did not actually
+ *   authenticate it. This middleware runs BEFORE routing, so it catches that case.
+ *
+ * Why it is scoped to API paths and not applied globally:
+ *   The analytics dashboard navigates between its public HTML pages with
+ *   `?api-key=` in the URL so the front-end can store the key in sessionStorage
+ *   and then send it via header on subsequent XHRs. That page-navigation pattern
+ *   is intentional and preserved. The leak we close here is the API-call pattern
+ *   where the credential ends up in proxy/access logs.
+ *
+ * Paths covered: /api/*, /mcp, /mcp/*, /admin, /admin/*.
+ */
+function rejectQueryStringApiKey() {
+    return function (req, res, next) {
+        const path = req.path || '';
+        const isApiPath = path.startsWith('/api/')
+            || path === '/mcp'
+            || path.startsWith('/mcp/')
+            || path === '/admin'
+            || path.startsWith('/admin/');
+        if (!isApiPath)
+            return next();
+        if (req.query && typeof req.query['api-key'] !== 'undefined') {
+            console.error(`[FRAIM AUTH] Rejected query-string api-key (pre-routing) for ${req.method} ${path}`);
+            return res.status(401).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32001,
+                    message: 'Unauthorized: API keys must be sent in the x-api-key header, not in the query string [AUTH-QUERY-FORBIDDEN]'
+                },
+                id: req.body?.id || null
+            });
+        }
+        return next();
+    };
+}

package/dist/src/middleware/security-headers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityHeaders = securityHeaders;
+const DEFAULT_CSP = [
+    "default-src 'self'",
+    // Inline scripts are used by the analytics/installer dashboard; keep them.
+    // Third-party CDNs are explicitly listed rather than wildcarded.
+    "script-src 'self' 'unsafe-inline' https://js.stripe.com https://cdn.jsdelivr.net",
+    "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com",
+    "img-src 'self' data: https:",
+    "font-src 'self' https://fonts.gstatic.com data:",
+    "connect-src 'self' https://api.stripe.com",
+    "frame-src 'self' https://js.stripe.com https://hooks.stripe.com",
+    "frame-ancestors 'self'",
+    "base-uri 'self'",
+    "form-action 'self' https://checkout.stripe.com"
+].join('; ');
+function securityHeaders(options = {}) {
+    const enableHsts = options.enableHsts !== false;
+    const csp = options.contentSecurityPolicy === undefined
+        ? DEFAULT_CSP
+        : options.contentSecurityPolicy;
+    return function securityHeadersMiddleware(req, res, next) {
+        // Trust-proxy aware: req.secure is true if X-Forwarded-Proto is https
+        // and Express has been told to trust the upstream (see fraim-mcp-server.ts).
+        if (enableHsts && req.secure) {
+            res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
+        }
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+        res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+        res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+        res.setHeader('Cross-Origin-Resource-Policy', 'same-site');
+        res.setHeader('X-Permitted-Cross-Domain-Policies', 'none');
+        res.setHeader('X-DNS-Prefetch-Control', 'off');
+        if (csp) {
+            res.setHeader('Content-Security-Policy', csp);
+        }
+        next();
+    };
+}

package/dist/src/middleware/telemetry.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryMiddleware = void 0;
+class TelemetryMiddleware {
+    constructor(sessionManager) {
+        this.sessionManager = sessionManager;
+    }
+    parseSessionId(req) {
+        const fromHeader = Array.isArray(req.headers['x-fraim-session-id'])
+            ? req.headers['x-fraim-session-id'][0]
+            : req.headers['x-fraim-session-id'];
+        if (typeof fromHeader === 'string' && fromHeader.trim().length > 0) {
+            return fromHeader.trim();
+        }
+        const fromParams = req.body?.params?.sessionId;
+        if (typeof fromParams === 'string' && fromParams.trim().length > 0) {
+            return fromParams.trim();
+        }
+        const fromArgs = req.body?.params?.arguments?.sessionId;
+        if (typeof fromArgs === 'string' && fromArgs.trim().length > 0) {
+            return fromArgs.trim();
+        }
+        return undefined;
+    }
+    /**
+     * Middleware to enforce Session Handshake and track activity
+     */
+    async handle(req, res, next) {
+        try {
+            // 1. Standard MCP Lifecycle & Discovery methods (Initialize, List Tools/Resources/Prompts, etc.)
+            const exemptMethods = [
+                'initialize',
+                'notifications/initialized',
+                'tools/list',
+                'resources/list',
+                'prompts/list',
+                'prompts/get',
+                'logging/setLevel'
+            ];
+            if (req.body && exemptMethods.includes(req.body.method)) {
+                return next();
+            }
+            // 2. FRAIM Bootstrap/Discovery Tools that don't need an active session
+            if (req.body && req.body.method === 'tools/call') {
+                const toolName = req.body.params?.name;
+                const safeTools = [
+                    'fraim_connect',
+                    'list_fraim_jobs'
+                ];
+                if (toolName && safeTools.includes(toolName)) {
+                    return next();
+                }
+            }
+            // Skip for non-authenticated or exempt paths (GET only).
+            // Issue #359 - /api/auth/* and /api/account/* are human-session lifecycle
+            // endpoints (called by auth-bootstrap.js on every page load); they happen
+            // BEFORE any agent has fraim_connect'd, so they MUST be exempt from the
+            // telemetry session-active gate. Without this, /api/auth/session returns 400
+            // for every signed-in browser, which redirects users back to sign-in.
+            // Issue #563 - /api/org/* serves the org-cache sync performed by the
+            // `fraim sync` CLI, which runs outside any MCP session (same lifecycle
+            // position as /api/registry/sync). Auth still applies; only the
+            // session-active gate is exempted.
+            const exemptPaths = ['/health', '/admin', '/api/registry/sync', '/api/registry/github-workflows', '/api/registry/topology/personalized', '/api/registry/topology/usage-heatmap', '/api/org/', '/api/manager/', '/api/payment/', '/api/sales/', '/api/signup', '/api/providers', '/api/analytics', '/analytics', '/api/auth/', '/api/account/'];
+            if (exemptPaths.some(p => req.path.startsWith(p))) {
+                return next();
+            }
+            const apiKey = req.apiKeyData?.key;
+            if (!apiKey)
+                return next(); // Auth middleware handles 401 earlier
+            const sessionId = this.parseSessionId(req);
+            const localVersionFromHeader = Array.isArray(req.headers['x-fraim-local-version'])
+                ? req.headers['x-fraim-local-version'][0]
+                : req.headers['x-fraim-local-version'];
+            const localVersion = req.localMcpVersion ||
+                (typeof localVersionFromHeader === 'string' ? localVersionFromHeader : 'unknown');
+            const isProxiedAgentCall = typeof localVersion === 'string' && localVersion !== 'unknown';
+            // Enforce explicit session id for local proxy agent traffic.
+            if (isProxiedAgentCall && !sessionId) {
+                return res.status(400).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32600,
+                        message: `Missing Session ID. REQUIRED ACTION:
+1. Call 'fraim_connect' first
+2. Capture the returned sessionId
+3. Include that sessionId on every subsequent FRAIM tool call (params.sessionId or params.arguments.sessionId).`
+                    },
+                    id: req.body?.id || null
+                });
+            }
+            // Check Session
+            const isActive = await this.sessionManager.updateActivity(apiKey, sessionId);
+            if (!isActive) {
+                const sessionStartGuidance = isProxiedAgentCall
+                    ? `Session Not Started. REQUIRED ACTION: Call 'fraim_connect' tool first, then include the returned sessionId on every subsequent FRAIM tool call.`
+                    : `Session Not Started. REQUIRED ACTION: Call 'fraim_connect' tool first with these parameters:
+
+{
+  "agent": {
+    "name": "YourAgentName",
+    "model": "your-model-name"
+  },
+  "machine": {
+    "hostname": "use os.hostname()",
+    "platform": "use process.platform"
+  },
+  "repo": {
+    "url": "git remote URL",
+    "owner": "repo owner",
+    "name": "repo name"
+  }
+}
+
+After successful fraim_connect, all other FRAIM tools will work. This is required for telemetry and session management.`;
+                return res.status(400).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32600,
+                        message: sessionStartGuidance
+                    },
+                    id: req.body?.id || null
+                });
+            }
+            console.log(`Telemetry active for ${apiKey}`);
+            return next();
+        }
+        catch (error) {
+            console.error('Telemetry middleware error:', error);
+            return next(error);
+        }
+    }
+}
+exports.TelemetryMiddleware = TelemetryMiddleware;

package/dist/src/models/payment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });