recker 1.0.31 → 1.0.32-next.e0741bf

package/dist/seo/rules/redirects.js

@@ -0,0 +1,193 @@
+import { createResult } from './types.js';
+export const redirectRules = [
+    {
+        id: 'redirect-chain-length',
+        name: 'Redirect Chain Length',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Redirect chains should not exceed 3 hops',
+        check: (ctx) => {
+            if (ctx.redirectChain === undefined)
+                return null;
+            const chainLength = ctx.redirectChain.length;
+            if (chainLength === 0) {
+                return createResult({ id: 'redirect-chain-length', name: 'Redirect Chain Length', category: 'technical', severity: 'warning' }, 'pass', 'No redirects detected');
+            }
+            if (chainLength > 5) {
+                return createResult({ id: 'redirect-chain-length', name: 'Redirect Chain Length', category: 'technical', severity: 'warning' }, 'fail', `Redirect chain has ${chainLength} hops (excessive)`, {
+                    value: chainLength,
+                    recommendation: 'Consolidate redirects to point directly to final URL',
+                    evidence: {
+                        found: ctx.redirectChain.map(r => `${r.status} ${r.from} → ${r.to}`),
+                        expected: 'Direct link to final destination',
+                        impact: 'Long redirect chains waste crawl budget and increase latency'
+                    }
+                });
+            }
+            if (chainLength > 3) {
+                return createResult({ id: 'redirect-chain-length', name: 'Redirect Chain Length', category: 'technical', severity: 'warning' }, 'warn', `Redirect chain has ${chainLength} hops`, {
+                    value: chainLength,
+                    recommendation: 'Reduce redirect chain by updating original links',
+                    evidence: {
+                        found: ctx.redirectChain.map(r => `${r.status} ${r.from} → ${r.to}`),
+                        expected: 'Maximum 3 redirects',
+                        impact: 'Excessive redirects slow page load and lose link equity'
+                    }
+                });
+            }
+            return createResult({ id: 'redirect-chain-length', name: 'Redirect Chain Length', category: 'technical', severity: 'warning' }, 'info', `Page reached after ${chainLength} redirect(s)`, {
+                value: chainLength,
+                evidence: {
+                    found: ctx.redirectChain.map(r => `${r.status} ${r.from} → ${r.to}`)
+                }
+            });
+        },
+    },
+    {
+        id: 'redirect-loop',
+        name: 'Redirect Loop',
+        category: 'technical',
+        severity: 'error',
+        description: 'Pages should not create redirect loops',
+        check: (ctx) => {
+            if (!ctx.redirectChain || ctx.redirectChain.length === 0)
+                return null;
+            const urls = ctx.redirectChain.map(r => r.from);
+            urls.push(ctx.redirectChain[ctx.redirectChain.length - 1].to);
+            const seen = new Set();
+            let loopUrl;
+            for (const url of urls) {
+                const normalized = normalizeUrl(url);
+                if (seen.has(normalized)) {
+                    loopUrl = url;
+                    break;
+                }
+                seen.add(normalized);
+            }
+            if (loopUrl) {
+                return createResult({ id: 'redirect-loop', name: 'Redirect Loop', category: 'technical', severity: 'error' }, 'fail', 'Redirect loop detected', {
+                    recommendation: 'Fix server configuration to break the redirect loop',
+                    evidence: {
+                        found: ctx.redirectChain.map(r => `${r.status} ${r.from} → ${r.to}`),
+                        issue: `Loop at: ${loopUrl}`,
+                        impact: 'Redirect loops prevent page from being crawled and indexed'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'redirect-type',
+        name: 'Redirect Type',
+        category: 'technical',
+        severity: 'info',
+        description: 'Permanent content moves should use 301 redirects',
+        check: (ctx) => {
+            if (!ctx.redirectChain || ctx.redirectChain.length === 0)
+                return null;
+            const temporary = ctx.redirectChain.filter(r => r.status === 302 || r.status === 307);
+            const permanent = ctx.redirectChain.filter(r => r.status === 301 || r.status === 308);
+            if (temporary.length > 0 && permanent.length === 0) {
+                return createResult({ id: 'redirect-type', name: 'Redirect Type', category: 'technical', severity: 'info' }, 'warn', `Using temporary redirect (${temporary[0].status})`, {
+                    recommendation: 'Use 301 redirect for permanent URL changes to pass link equity',
+                    evidence: {
+                        found: `${temporary[0].status} ${temporary[0].from} → ${temporary[0].to}`,
+                        expected: '301 for permanent moves, 302 only for temporary changes',
+                        impact: 'Temporary redirects may not pass full link equity'
+                    }
+                });
+            }
+            if (permanent.length > 0) {
+                return createResult({ id: 'redirect-type', name: 'Redirect Type', category: 'technical', severity: 'info' }, 'pass', 'Using permanent redirect (301)');
+            }
+            return null;
+        },
+    },
+    {
+        id: 'www-consistency',
+        name: 'WWW vs Non-WWW',
+        category: 'canonicalization',
+        severity: 'warning',
+        description: 'Site should redirect consistently to either WWW or non-WWW version',
+        check: (ctx) => {
+            if (ctx.wwwConsistency === undefined)
+                return null;
+            const { canonicalHasWww, urlHasWww, redirectsToCanonical } = ctx.wwwConsistency;
+            if (canonicalHasWww !== urlHasWww && !redirectsToCanonical) {
+                return createResult({ id: 'www-consistency', name: 'WWW vs Non-WWW', category: 'canonicalization', severity: 'warning' }, 'warn', 'WWW/non-WWW version accessible without redirect', {
+                    recommendation: 'Set up 301 redirect from non-canonical version to canonical',
+                    evidence: {
+                        found: urlHasWww ? 'www version' : 'non-www version',
+                        expected: `Redirect to ${canonicalHasWww ? 'www' : 'non-www'} version`,
+                        impact: 'Duplicate content issues when both versions are accessible'
+                    }
+                });
+            }
+            return createResult({ id: 'www-consistency', name: 'WWW vs Non-WWW', category: 'canonicalization', severity: 'warning' }, 'pass', 'WWW handling is consistent');
+        },
+    },
+    {
+        id: 'http-to-https-redirect',
+        name: 'HTTP to HTTPS Redirect',
+        category: 'security',
+        severity: 'warning',
+        description: 'HTTP version should redirect to HTTPS',
+        check: (ctx) => {
+            if (ctx.httpRedirectsToHttps === undefined)
+                return null;
+            if (!ctx.httpRedirectsToHttps) {
+                return createResult({ id: 'http-to-https-redirect', name: 'HTTP to HTTPS Redirect', category: 'security', severity: 'warning' }, 'warn', 'HTTP version does not redirect to HTTPS', {
+                    recommendation: 'Configure server to redirect HTTP traffic to HTTPS',
+                    evidence: {
+                        found: 'HTTP accessible without redirect',
+                        expected: '301 redirect from HTTP to HTTPS',
+                        impact: 'Users may access insecure version; duplicate content issues',
+                        learnMore: 'https://web.dev/why-https-matters/'
+                    }
+                });
+            }
+            return createResult({ id: 'http-to-https-redirect', name: 'HTTP to HTTPS Redirect', category: 'security', severity: 'warning' }, 'pass', 'HTTP properly redirects to HTTPS');
+        },
+    },
+    {
+        id: 'cross-domain-redirect',
+        name: 'Cross-Domain Redirect',
+        category: 'technical',
+        severity: 'info',
+        description: 'Detects redirects to different domains',
+        check: (ctx) => {
+            if (!ctx.redirectChain || ctx.redirectChain.length === 0)
+                return null;
+            const crossDomainRedirects = ctx.redirectChain.filter(r => {
+                try {
+                    const fromHost = new URL(r.from).hostname;
+                    const toHost = new URL(r.to).hostname;
+                    return fromHost !== toHost;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (crossDomainRedirects.length > 0) {
+                return createResult({ id: 'cross-domain-redirect', name: 'Cross-Domain Redirect', category: 'technical', severity: 'info' }, 'info', `${crossDomainRedirects.length} cross-domain redirect(s) detected`, {
+                    value: crossDomainRedirects.length,
+                    evidence: {
+                        found: crossDomainRedirects.map(r => `${r.from} → ${r.to}`),
+                        impact: 'Cross-domain redirects may indicate site migration or tracking'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+];
+function normalizeUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.protocol}//${u.hostname}${u.pathname.replace(/\/$/, '')}${u.search}`;
+    }
+    catch {
+        return url.toLowerCase();
+    }
+}

package/dist/seo/rules/resources.d.ts

@@ -0,0 +1,2 @@
+import { SeoRule } from './types.js';
+export declare const resourceRules: SeoRule[];

package/dist/seo/rules/resources.js

@@ -0,0 +1,373 @@
+import { createResult } from './types.js';
+export const resourceRules = [
+    {
+        id: 'resources-js-files-count',
+        name: 'JavaScript File Count',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Too many JavaScript files increase HTTP requests and slow page load',
+        check: (ctx) => {
+            if (ctx.jsFilesCount === undefined)
+                return null;
+            const max = 15;
+            if (ctx.jsFilesCount > max) {
+                return createResult({ id: 'resources-js-files-count', name: 'JavaScript File Count', category: 'resources', severity: 'warning' }, 'warn', `Too many JS files (${ctx.jsFilesCount})`, {
+                    value: ctx.jsFilesCount,
+                    recommendation: `Bundle JavaScript files to reduce HTTP requests (max ${max})`,
+                    evidence: {
+                        found: ctx.jsFilesCount,
+                        expected: `${max} or fewer`,
+                        impact: 'Each HTTP request adds latency and slows page load',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-js-total-size',
+        name: 'JavaScript Total Size',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Large JavaScript bundles slow page load and increase bandwidth',
+        check: (ctx) => {
+            if (ctx.jsTotalSize === undefined)
+                return null;
+            const maxKB = 500;
+            const sizeKB = Math.round(ctx.jsTotalSize / 1024);
+            if (sizeKB > maxKB) {
+                return createResult({ id: 'resources-js-total-size', name: 'JavaScript Total Size', category: 'resources', severity: 'warning' }, 'warn', `Large JS bundle (${sizeKB}KB)`, {
+                    value: sizeKB,
+                    recommendation: `Reduce JavaScript size to under ${maxKB}KB`,
+                    evidence: {
+                        found: `${sizeKB}KB`,
+                        expected: `${maxKB}KB or less`,
+                        impact: 'Large JS bundles delay page interactivity',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-js-render-blocking',
+        name: 'Render-Blocking JavaScript',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Render-blocking JS in <head> delays page rendering',
+        check: (ctx) => {
+            if (ctx.renderBlockingJs === undefined)
+                return null;
+            if (ctx.renderBlockingJs > 0) {
+                return createResult({ id: 'resources-js-render-blocking', name: 'Render-Blocking JavaScript', category: 'resources', severity: 'warning' }, 'warn', `${ctx.renderBlockingJs} render-blocking JS file(s)`, {
+                    value: ctx.renderBlockingJs,
+                    recommendation: 'Add async or defer attribute to non-critical scripts',
+                    evidence: {
+                        found: `${ctx.renderBlockingJs} scripts without async/defer`,
+                        expected: 'All scripts with async, defer, or in body',
+                        example: '<script src="app.js" defer></script>',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-js-render-blocking', name: 'Render-Blocking JavaScript', category: 'resources', severity: 'warning' }, 'pass', 'No render-blocking JavaScript');
+        },
+    },
+    {
+        id: 'resources-css-files-count',
+        name: 'CSS File Count',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Too many CSS files increase HTTP requests',
+        check: (ctx) => {
+            if (ctx.cssFilesCount === undefined)
+                return null;
+            const max = 10;
+            if (ctx.cssFilesCount > max) {
+                return createResult({ id: 'resources-css-files-count', name: 'CSS File Count', category: 'resources', severity: 'warning' }, 'warn', `Too many CSS files (${ctx.cssFilesCount})`, {
+                    value: ctx.cssFilesCount,
+                    recommendation: `Bundle CSS files to reduce HTTP requests (max ${max})`,
+                    evidence: {
+                        found: ctx.cssFilesCount,
+                        expected: `${max} or fewer`,
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-css-total-size',
+        name: 'CSS Total Size',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Large CSS files delay page rendering',
+        check: (ctx) => {
+            if (ctx.cssTotalSize === undefined)
+                return null;
+            const maxKB = 200;
+            const sizeKB = Math.round(ctx.cssTotalSize / 1024);
+            if (sizeKB > maxKB) {
+                return createResult({ id: 'resources-css-total-size', name: 'CSS Total Size', category: 'resources', severity: 'warning' }, 'warn', `Large CSS bundle (${sizeKB}KB)`, {
+                    value: sizeKB,
+                    recommendation: `Reduce CSS size to under ${maxKB}KB`,
+                    evidence: {
+                        found: `${sizeKB}KB`,
+                        expected: `${maxKB}KB or less`,
+                        impact: 'Large CSS delays first contentful paint',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-css-render-blocking',
+        name: 'Render-Blocking CSS',
+        category: 'resources',
+        severity: 'info',
+        description: 'Critical CSS should be inlined, non-critical deferred',
+        check: (ctx) => {
+            if (ctx.cssFilesCount === undefined)
+                return null;
+            if (ctx.cssFilesCount > 3 && !ctx.hasCriticalCss) {
+                return createResult({ id: 'resources-css-render-blocking', name: 'Render-Blocking CSS', category: 'resources', severity: 'info' }, 'info', `${ctx.cssFilesCount} CSS files blocking render`, {
+                    value: ctx.cssFilesCount,
+                    recommendation: 'Consider inlining critical CSS and lazy-loading the rest',
+                    evidence: {
+                        impact: 'CSS blocks rendering until fully loaded',
+                        example: '<link rel="preload" href="style.css" as="style" onload="this.rel=\'stylesheet\'">',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-image-size-large',
+        name: 'Large Image Files',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Images over 200KB should be optimized',
+        check: (ctx) => {
+            if (!ctx.largeImages || ctx.largeImages.length === 0)
+                return null;
+            const maxKB = 200;
+            const largeCount = ctx.largeImages.length;
+            return createResult({ id: 'resources-image-size-large', name: 'Large Image Files', category: 'resources', severity: 'warning' }, 'warn', `${largeCount} image(s) over ${maxKB}KB`, {
+                value: largeCount,
+                recommendation: 'Compress images or use modern formats (WebP, AVIF)',
+                evidence: {
+                    found: ctx.largeImages.slice(0, 5),
+                    impact: 'Large images significantly slow page load',
+                },
+            });
+        },
+    },
+    {
+        id: 'resources-image-format',
+        name: 'Modern Image Formats',
+        category: 'resources',
+        severity: 'info',
+        description: 'Use WebP or AVIF for better compression',
+        check: (ctx) => {
+            if (ctx.imagesTotal === undefined || ctx.imagesTotal === 0)
+                return null;
+            if (ctx.modernFormatImages === undefined)
+                return null;
+            const modernPercent = (ctx.modernFormatImages / ctx.imagesTotal) * 100;
+            if (modernPercent < 50) {
+                return createResult({ id: 'resources-image-format', name: 'Modern Image Formats', category: 'resources', severity: 'info' }, 'info', `Only ${Math.round(modernPercent)}% of images use modern formats`, {
+                    value: ctx.modernFormatImages,
+                    recommendation: 'Convert images to WebP or AVIF for 25-50% smaller files',
+                    evidence: {
+                        found: `${ctx.modernFormatImages}/${ctx.imagesTotal} modern format images`,
+                        expected: 'WebP or AVIF for all images',
+                        impact: 'Modern formats reduce image size by 25-50%',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-image-format', name: 'Modern Image Formats', category: 'resources', severity: 'info' }, 'pass', `${Math.round(modernPercent)}% of images use modern formats`);
+        },
+    },
+    {
+        id: 'resources-image-dimensions',
+        name: 'Image Dimensions',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Images should have width and height attributes',
+        check: (ctx) => {
+            if (ctx.imagesMissingDimensions === undefined)
+                return null;
+            if (ctx.imagesMissingDimensions > 0) {
+                return createResult({ id: 'resources-image-dimensions', name: 'Image Dimensions', category: 'resources', severity: 'warning' }, 'warn', `${ctx.imagesMissingDimensions} image(s) missing width/height`, {
+                    value: ctx.imagesMissingDimensions,
+                    recommendation: 'Add width and height attributes to prevent layout shift',
+                    evidence: {
+                        impact: 'Missing dimensions cause Cumulative Layout Shift (CLS)',
+                        example: '<img src="photo.jpg" width="800" height="600" alt="Photo">',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-image-dimensions', name: 'Image Dimensions', category: 'resources', severity: 'warning' }, 'pass', 'All images have width/height attributes');
+        },
+    },
+    {
+        id: 'resources-font-files',
+        name: 'Web Font Files',
+        category: 'resources',
+        severity: 'info',
+        description: 'Too many font files can slow page load',
+        check: (ctx) => {
+            if (ctx.fontFilesCount === undefined)
+                return null;
+            const max = 4;
+            if (ctx.fontFilesCount > max) {
+                return createResult({ id: 'resources-font-files', name: 'Web Font Files', category: 'resources', severity: 'info' }, 'info', `${ctx.fontFilesCount} font files loaded`, {
+                    value: ctx.fontFilesCount,
+                    recommendation: `Limit to ${max} font files or use variable fonts`,
+                    evidence: {
+                        found: ctx.fontFilesCount,
+                        expected: `${max} or fewer`,
+                        impact: 'Each font file adds to page weight and load time',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-font-display',
+        name: 'Font Display Strategy',
+        category: 'resources',
+        severity: 'info',
+        description: 'Use font-display: swap to prevent invisible text during load',
+        check: (ctx) => {
+            if (ctx.hasFontDisplaySwap === undefined)
+                return null;
+            if (!ctx.hasFontDisplaySwap && ctx.fontFilesCount && ctx.fontFilesCount > 0) {
+                return createResult({ id: 'resources-font-display', name: 'Font Display Strategy', category: 'resources', severity: 'info' }, 'info', 'font-display: swap not detected', {
+                    recommendation: 'Add font-display: swap to @font-face rules',
+                    evidence: {
+                        expected: '@font-face { font-display: swap; }',
+                        impact: 'Without swap, text may be invisible during font load (FOIT)',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'resources-total-requests',
+        name: 'Total HTTP Requests',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Too many HTTP requests slow page load',
+        check: (ctx) => {
+            if (ctx.totalRequests === undefined)
+                return null;
+            const max = 50;
+            if (ctx.totalRequests > max) {
+                return createResult({ id: 'resources-total-requests', name: 'Total HTTP Requests', category: 'resources', severity: 'warning' }, 'warn', `Too many HTTP requests (${ctx.totalRequests})`, {
+                    value: ctx.totalRequests,
+                    recommendation: `Reduce to under ${max} requests by bundling and optimizing`,
+                    evidence: {
+                        found: ctx.totalRequests,
+                        expected: `${max} or fewer`,
+                        impact: 'Each HTTP request adds latency',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-total-requests', name: 'Total HTTP Requests', category: 'resources', severity: 'warning' }, 'pass', `Good HTTP request count (${ctx.totalRequests})`);
+        },
+    },
+    {
+        id: 'resources-total-size',
+        name: 'Total Page Size',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Total page weight affects load time',
+        check: (ctx) => {
+            if (ctx.totalPageSize === undefined)
+                return null;
+            const maxMB = 3;
+            const sizeMB = ctx.totalPageSize / (1024 * 1024);
+            if (sizeMB > maxMB) {
+                return createResult({ id: 'resources-total-size', name: 'Total Page Size', category: 'resources', severity: 'warning' }, 'warn', `Large page size (${sizeMB.toFixed(1)}MB)`, {
+                    value: Math.round(ctx.totalPageSize / 1024),
+                    recommendation: `Reduce total page size to under ${maxMB}MB`,
+                    evidence: {
+                        found: `${sizeMB.toFixed(1)}MB`,
+                        expected: `${maxMB}MB or less`,
+                        impact: 'Large pages are slow on mobile and low-bandwidth connections',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-total-size', name: 'Total Page Size', category: 'resources', severity: 'warning' }, 'pass', `Good page size (${sizeMB.toFixed(1)}MB)`);
+        },
+    },
+    {
+        id: 'resources-compression',
+        name: 'Resource Compression',
+        category: 'resources',
+        severity: 'warning',
+        description: 'Text resources should be compressed with gzip or brotli',
+        check: (ctx) => {
+            if (ctx.uncompressedResources === undefined)
+                return null;
+            if (ctx.uncompressedResources > 0) {
+                return createResult({ id: 'resources-compression', name: 'Resource Compression', category: 'resources', severity: 'warning' }, 'warn', `${ctx.uncompressedResources} uncompressed resource(s)`, {
+                    value: ctx.uncompressedResources,
+                    recommendation: 'Enable gzip or Brotli compression on your server',
+                    evidence: {
+                        impact: 'Compression typically reduces file size by 60-80%',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-compression', name: 'Resource Compression', category: 'resources', severity: 'warning' }, 'pass', 'All text resources are compressed');
+        },
+    },
+    {
+        id: 'resources-caching',
+        name: 'Browser Caching',
+        category: 'resources',
+        severity: 'info',
+        description: 'Static resources should have long cache lifetimes',
+        check: (ctx) => {
+            if (ctx.resourcesWithoutCaching === undefined)
+                return null;
+            if (ctx.resourcesWithoutCaching > 0) {
+                return createResult({ id: 'resources-caching', name: 'Browser Caching', category: 'resources', severity: 'info' }, 'info', `${ctx.resourcesWithoutCaching} resource(s) without proper caching`, {
+                    value: ctx.resourcesWithoutCaching,
+                    recommendation: 'Set Cache-Control headers for static resources',
+                    evidence: {
+                        expected: 'Cache-Control: max-age=31536000 for static assets',
+                        impact: 'Proper caching improves repeat visit performance',
+                    },
+                });
+            }
+            return createResult({ id: 'resources-caching', name: 'Browser Caching', category: 'resources', severity: 'info' }, 'pass', 'Static resources have proper caching');
+        },
+    },
+    {
+        id: 'broken-external-resources',
+        name: 'Broken External Resources',
+        category: 'resources',
+        severity: 'warning',
+        description: 'External JS/CSS files should be accessible',
+        check: (ctx) => {
+            if (ctx.brokenExternalResources === undefined)
+                return null;
+            if (ctx.brokenExternalResources > 0) {
+                return createResult({ id: 'broken-external-resources', name: 'Broken External Resources', category: 'resources', severity: 'warning' }, 'warn', `${ctx.brokenExternalResources} broken external JS/CSS files`, {
+                    value: ctx.brokenExternalResources,
+                    recommendation: 'Fix or remove references to broken external resources',
+                    evidence: {
+                        found: ctx.brokenExternalResourceUrls?.slice(0, 5) || [],
+                        impact: 'Broken resources may cause rendering issues and affect user experience'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+];