@hagicode/hagilight 0.3.2-dev.55.1.1e29eba → 0.3.2-dev.57.1.ee1f17e

package/SEOHead.astro

@@ -1,15 +1,10 @@
 ---
 import {
-  composeCoreSeoHead,
+  composeCanonicalSeoHead,
   resolveSeoMetadata,
   serializeJsonLd,
-} from './seo-utils.mjs';
-
-interface HeadEntry {
-  tag: string;
-  attrs?: Record<string, string | boolean | number | undefined>;
-  content?: string;
-}
+  type HeadEntry,
+} from '@hagicode/hagilight-core/seo';
 
 interface Props {
   page?: {
@@ -46,7 +41,7 @@ const metadata = {
   site,
 };
 const canonicalUrl = page.url?.toString() ?? currentPageUrl;
-const composedHead = composeCoreSeoHead(head, metadata, {
+const composedHead = composeCanonicalSeoHead(head, metadata, {
   canonicalUrl,
   explicitHead: [head],
 });

package/dist/integration.d.ts

@@ -0,0 +1,33 @@
+import type { AstroIntegration } from 'astro';
+import { type FaviconOptions } from '@hagicode/hagilight-core/favicon';
+import { type RssLocalesInput } from '@hagicode/hagilight-core/rss';
+import { RSS_OWNER, type RssOwnerClaim } from '@hagicode/hagilight-core/rss-ownership';
+export type { RssFeedCallback, RssFeedContent, RssFeedRequest, RssFooterContext, } from './rss-config.js';
+export interface HagilightOptions {
+    /** Generate `sitemap-index.xml` and `robots.txt`. Defaults to `true`. */
+    enabled?: boolean;
+}
+export interface HagilightRssOptions {
+    /** Starlight-shaped locale map, for example `{ root: { lang: 'en-US' }, 'zh-CN': { lang: 'zh-CN' } }`. */
+    locales: RssLocalesInput;
+    /** Project-root-relative module whose default export is an `RssFeedCallback`. */
+    getFeed: string;
+}
+export type HagilightFaviconOptions = FaviconOptions;
+export type HagilightRssIntegration = AstroIntegration & {
+    readonly [RSS_OWNER]: RssOwnerClaim;
+};
+/**
+ * Generate a sitemap and `robots.txt` for a plain Astro site. An existing
+ * `@astrojs/sitemap` or Starlight integration owns sitemap generation, and a
+ * consumer-owned robots page or public file takes precedence.
+ */
+export declare function hagilight({ enabled }?: HagilightOptions): AstroIntegration;
+/** Inject the bundled HagiCode favicon unless the site head already declares an icon. */
+export declare function hagilightFavicon(options?: HagilightFaviconOptions): AstroIntegration;
+/**
+ * Generate localized `/rss.xml`, `/rss.en.xml`, and `/rss.<language>.xml`
+ * routes and expose their URLs to the plain-Astro Footer. An enabled Starlight
+ * Hagilight RSS integration in the same project owns the routes instead.
+ */
+export declare function hagilightRss(input: HagilightRssOptions): HagilightRssIntegration;

package/dist/integration.js

@@ -0,0 +1,243 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { extname, isAbsolute, resolve, win32 } from 'node:path';
+import sitemap from '@astrojs/sitemap';
+import { resolveFaviconHeadEntry } from '@hagicode/hagilight-core/favicon';
+import { resolveRssLocales } from '@hagicode/hagilight-core/rss';
+import { RSS_OWNER, resolvePlainAstroRssOwner, } from '@hagicode/hagilight-core/rss-ownership';
+const VIRTUAL_RSS_CONFIG = 'virtual:hagilight/rss-config';
+const VIRTUAL_RSS_CONFIG_RESOLVED = `\0${VIRTUAL_RSS_CONFIG}`;
+const PAGE_SOURCE_EXTENSIONS = new Set(['.astro', '.html', '.js', '.jsx', '.md', '.mdx', '.ts', '.tsx']);
+const packageRoot = new URL('../', import.meta.url);
+const routeEntrypoint = (name) => fileURLToPath(new URL(name, packageRoot));
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function integrationName(integration) {
+    return isRecord(integration) ? integration.name : undefined;
+}
+function resolveDiscoverySite(site) {
+    const message = 'Hagilight sitemap and robots require an absolute HTTP(S) Astro site URL. Set `site` in astro.config.mjs.';
+    let parsed;
+    try {
+        parsed = new URL(site);
+    }
+    catch {
+        throw new Error(message);
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || !parsed.hostname || parsed.username || parsed.password) {
+        throw new Error(message);
+    }
+    return parsed;
+}
+/**
+ * Generate a sitemap and `robots.txt` for a plain Astro site. An existing
+ * `@astrojs/sitemap` or Starlight integration owns sitemap generation, and a
+ * consumer-owned robots page or public file takes precedence.
+ */
+export function hagilight({ enabled = true } = {}) {
+    if (typeof enabled !== 'boolean') {
+        throw new TypeError('Hagilight sitemap and robots enabled option must be a boolean.');
+    }
+    return {
+        name: '@hagicode/hagilight:discovery',
+        hooks: {
+            'astro:config:setup'({ config, injectRoute, updateConfig }) {
+                if (!enabled)
+                    return;
+                resolveDiscoverySite(config.site);
+                const integrations = config.integrations ?? [];
+                if (!integrations.some((integration) => {
+                    const name = integrationName(integration);
+                    return name === '@astrojs/sitemap' || name === '@astrojs/starlight';
+                })) {
+                    updateConfig({ integrations: [sitemap()] });
+                }
+                const pageRoot = resolve(fileURLToPath(config.srcDir), 'pages');
+                const publicRoot = fileURLToPath(config.publicDir);
+                const hasRobotsPage = existsSync(pageRoot) && readdirSync(pageRoot).some((name) => /^robots\.txt\.(?:astro|html|js|jsx|md|mdx|ts|tsx)$/u.test(name)
+                    || name === 'robots.txt');
+                if (!hasRobotsPage && !existsSync(resolve(publicRoot, 'robots.txt'))) {
+                    injectRoute({
+                        pattern: '/robots.txt',
+                        entrypoint: routeEntrypoint('robots.txt.ts'),
+                        prerender: true,
+                    });
+                }
+            },
+        },
+    };
+}
+/** Inject the bundled HagiCode favicon unless the site head already declares an icon. */
+export function hagilightFavicon(options = {}) {
+    if (!isRecord(options)) {
+        throw new TypeError('Hagilight favicon options must be an object.');
+    }
+    return {
+        name: '@hagicode/hagilight:favicon',
+        hooks: {
+            'astro:config:setup'({ config, updateConfig }) {
+                const head = config.head;
+                const entry = resolveFaviconHeadEntry(head, options);
+                if (!entry)
+                    return;
+                updateConfig({ head: [...(head ?? []), entry] });
+            },
+        },
+    };
+}
+function resolveRssOptions(options) {
+    if (!isRecord(options)) {
+        throw new TypeError('Hagilight RSS integration options must be an object.');
+    }
+    const locales = resolveRssLocales(options.locales, { requireNonEmpty: true });
+    if (typeof options.getFeed !== 'string' || !options.getFeed.trim()) {
+        throw new TypeError('Hagilight RSS getFeed must be a non-empty module path such as "./src/rss-feed.mjs".');
+    }
+    return { locales, getFeed: options.getFeed.trim() };
+}
+function resolveSite(site) {
+    let parsed;
+    try {
+        parsed = new URL(site);
+    }
+    catch {
+        throw new Error('Hagilight RSS requires an absolute Astro site URL. Set `site` in astro.config.mjs.');
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password) {
+        throw new Error('Hagilight RSS requires an absolute HTTP(S) Astro site URL.');
+    }
+    return parsed.href;
+}
+function resolveFeedModule(root, reference) {
+    if (reference.startsWith('file:') || isAbsolute(reference) || win32.isAbsolute(reference)) {
+        throw new TypeError('Hagilight RSS getFeed must be a path relative to the Astro project root.');
+    }
+    const modulePath = resolve(fileURLToPath(root), reference);
+    if (!existsSync(modulePath) || !statSync(modulePath).isFile()) {
+        throw new Error(`Hagilight RSS getFeed module "${reference}" was not found relative to the Astro project root.`);
+    }
+    return modulePath;
+}
+function assertNoRouteCollisions(config, locales) {
+    const expectedFiles = new Set(['rss.xml', 'rss.en.xml', ...locales.map(({ filename }) => `rss.${filename}.xml`)]);
+    const pageRoot = resolve(fileURLToPath(config.srcDir), 'pages');
+    const publicRoot = fileURLToPath(config.publicDir);
+    const collisions = [];
+    function findPageCollisions(directory) {
+        if (!existsSync(directory))
+            return;
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const entryPath = resolve(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'rss.xml' || /^rss\..+\.xml$/u.test(entry.name)) {
+                    for (const child of readdirSync(entryPath, { withFileTypes: true })) {
+                        if (child.isFile()
+                            && child.name.startsWith('index.')
+                            && PAGE_SOURCE_EXTENSIONS.has(extname(child.name))) {
+                            collisions.push(resolve(entryPath, child.name));
+                        }
+                    }
+                }
+                findPageCollisions(entryPath);
+            }
+            else if (entry.isFile()) {
+                const extension = extname(entry.name);
+                if (!PAGE_SOURCE_EXTENSIONS.has(extension))
+                    continue;
+                const sourceName = entry.name.slice(0, -extension.length);
+                if (expectedFiles.has(sourceName) || /^rss\..+\.xml$/u.test(sourceName)) {
+                    collisions.push(entryPath);
+                }
+            }
+        }
+    }
+    findPageCollisions(pageRoot);
+    for (const filename of expectedFiles) {
+        const publicFile = resolve(publicRoot, filename);
+        if (existsSync(publicFile) && statSync(publicFile).isFile())
+            collisions.push(publicFile);
+    }
+    if (collisions.length > 0) {
+        throw new Error(`Hagilight RSS route conflicts with consumer-owned file(s): ${collisions.join(', ')}. Remove the conflicting route or do not enable hagilightRss().`);
+    }
+}
+function createVirtualPlugin({ modulePath, site, baseUrl, locales, defaultFeedUrl, localeFeedUrls }) {
+    return {
+        name: '@hagicode/hagilight:rss',
+        resolveId(id) {
+            return id === VIRTUAL_RSS_CONFIG ? VIRTUAL_RSS_CONFIG_RESOLVED : null;
+        },
+        load(id) {
+            if (id !== VIRTUAL_RSS_CONFIG_RESOLVED)
+                return null;
+            return [
+                `import * as siteFeedModule from ${JSON.stringify(modulePath)};`,
+                'const config = {',
+                `  site: ${JSON.stringify(site)},`,
+                `  baseUrl: ${JSON.stringify(baseUrl)},`,
+                `  locales: ${JSON.stringify(locales)},`,
+                '  getFeed: siteFeedModule.default,',
+                `  footer: ${JSON.stringify({ defaultFeedUrl, localeFeedUrls, locales })},`,
+                '};',
+                'export default config;',
+            ].join('\n');
+        },
+    };
+}
+/**
+ * Generate localized `/rss.xml`, `/rss.en.xml`, and `/rss.<language>.xml`
+ * routes and expose their URLs to the plain-Astro Footer. An enabled Starlight
+ * Hagilight RSS integration in the same project owns the routes instead.
+ */
+export function hagilightRss(input) {
+    const options = resolveRssOptions(input);
+    return {
+        name: '@hagicode/hagilight:rss',
+        [RSS_OWNER]: { package: 'astro', enabled: true },
+        hooks: {
+            'astro:config:setup'({ config, injectRoute, addMiddleware, updateConfig }) {
+                if (resolvePlainAstroRssOwner(config.integrations) === 'starlight')
+                    return;
+                const site = resolveSite(config.site);
+                const modulePath = resolveFeedModule(config.root, options.getFeed);
+                assertNoRouteCollisions(config, options.locales);
+                const baseSegments = `${config.base || '/'}`
+                    .split('/')
+                    .filter(Boolean);
+                const baseUrl = baseSegments.length > 0 ? `/${baseSegments.join('/')}/` : '/';
+                const baseLocation = new URL(baseUrl, site);
+                const defaultFeedUrl = new URL('rss.xml', baseLocation).href;
+                const localeFeedUrls = Object.fromEntries(options.locales
+                    .filter(({ filename }) => filename !== 'en')
+                    .map(({ lang, filename }) => [lang, new URL(`rss.${filename}.xml`, baseLocation).href]));
+                injectRoute({
+                    pattern: '/rss.xml',
+                    entrypoint: routeEntrypoint('rss.xml.ts'),
+                    prerender: true,
+                });
+                injectRoute({
+                    pattern: '/rss.[language].xml',
+                    entrypoint: routeEntrypoint('rss.[language].xml.ts'),
+                    prerender: true,
+                });
+                addMiddleware({
+                    entrypoint: fileURLToPath(new URL('./rss-middleware.js', import.meta.url)),
+                    order: 'pre',
+                });
+                updateConfig({
+                    vite: {
+                        plugins: [createVirtualPlugin({
+                                modulePath,
+                                site,
+                                baseUrl,
+                                locales: options.locales,
+                                defaultFeedUrl,
+                                localeFeedUrls,
+                            })],
+                    },
+                });
+            },
+        },
+    };
+}

package/dist/rss-config.d.ts

@@ -0,0 +1,28 @@
+import type { RssFeedItem, RssLocale } from '@hagicode/hagilight-core/rss';
+export interface RssFeedRequest {
+    /** Locale route key from the configured `locales` map (`root` for the default locale). */
+    route: string;
+    /** Canonical language tag of the requested feed. */
+    lang: string;
+}
+export interface RssFeedContent {
+    title: string;
+    description: string;
+    items: readonly RssFeedItem[];
+}
+/** Default export of the module referenced by `hagilightRss({ getFeed })`. */
+export type RssFeedCallback = (request: RssFeedRequest) => RssFeedContent | Promise<RssFeedContent>;
+/** Request-local feed URLs that the plain-Astro Footer reads from `Astro.locals.hagilightRss`. */
+export interface RssFooterContext {
+    defaultFeedUrl: string;
+    localeFeedUrls: Readonly<Record<string, string>>;
+    locales: readonly RssLocale[];
+}
+/** Serialized configuration exposed to generated routes through `virtual:hagilight/rss-config`. */
+export interface RssRuntimeConfig {
+    site: string;
+    baseUrl: string;
+    locales: readonly RssLocale[];
+    getFeed: RssFeedCallback | undefined;
+    footer: RssFooterContext;
+}

package/dist/rss-config.js

@@ -0,0 +1 @@
+export {};

package/dist/rss-middleware.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareHandler } from 'astro';
+export declare const onRequest: MiddlewareHandler;

package/{rss-middleware.mjs → dist/rss-middleware.js}

@@ -1,6 +1,5 @@
 import rssConfig from 'virtual:hagilight/rss-config';
-
 export const onRequest = (context, next) => {
-  context.locals.hagilightRss = rssConfig.footer;
-  return next();
+    context.locals.hagilightRss = rssConfig.footer;
+    return next();
 };

package/dist/rss-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { RssRuntimeConfig } from './rss-config.js';
+export declare function renderRssFeed(config: Pick<RssRuntimeConfig, 'site' | 'baseUrl' | 'locales' | 'getFeed'>, filename: string | undefined): Promise<Response>;

package/dist/rss-runtime.js

@@ -0,0 +1,44 @@
+import { generateRssFeed } from '@hagicode/hagilight-core/rss';
+const EMPTY_ENGLISH_FEED = {
+    title: 'Hagilight RSS Feed',
+    description: 'English-language feed for this site.',
+    items: [],
+};
+export async function renderRssFeed(config, filename) {
+    const locale = config.locales.find((entry) => entry.filename === filename);
+    if (!locale && filename !== 'en') {
+        throw new Error(`Hagilight RSS has no configured locale for "${filename}".`);
+    }
+    let feed;
+    if (!locale) {
+        feed = EMPTY_ENGLISH_FEED;
+    }
+    else {
+        if (typeof config.getFeed !== 'function') {
+            throw new TypeError('Hagilight RSS getFeed module must default-export a callback function.');
+        }
+        const result = await config.getFeed({ route: locale.route, lang: locale.lang });
+        if (!result || typeof result !== 'object' || Array.isArray(result)) {
+            throw new TypeError(`Hagilight RSS getFeed callback for "${locale.lang}" must return an object.`);
+        }
+        const candidate = result;
+        if (typeof candidate.title !== 'string' || !candidate.title.trim()) {
+            throw new TypeError(`Hagilight RSS getFeed callback for "${locale.lang}" must return a non-empty title.`);
+        }
+        if (typeof candidate.description !== 'string' || !candidate.description.trim()) {
+            throw new TypeError(`Hagilight RSS getFeed callback for "${locale.lang}" must return a non-empty description.`);
+        }
+        if (!Array.isArray(candidate.items)) {
+            throw new TypeError(`Hagilight RSS getFeed callback for "${locale.lang}" must return an items array.`);
+        }
+        feed = candidate;
+    }
+    return generateRssFeed({
+        site: config.site,
+        baseUrl: config.baseUrl,
+        language: locale?.lang ?? 'en',
+        title: feed.title,
+        description: feed.description,
+        items: feed.items,
+    });
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@hagicode/hagilight",
-  "version": "0.3.2-dev.55.1.1e29eba",
+  "version": "0.3.2-dev.57.1.ee1f17e",
   "type": "module",
-  "description": "Shared Astro components for HagiCode sites",
+  "description": "Astro integrations and components for HagiCode sites",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/HagiCode-org/hagilight.git",
@@ -12,46 +12,39 @@
     "access": "public",
     "provenance": true
   },
+  "scripts": {
+    "build": "tsc -b",
+    "prepack": "tsc -b"
+  },
   "exports": {
-    "./Footer": "./Footer.astro",
-    "./Copyright": "./Copyright.astro",
-    "./PromotoBanner": "./PromotoBanner.astro",
-    "./logo.png": "./logo.png",
-    "./favicon.ico": "./favicon.ico",
-    "./favicon": "./favicon.mjs",
-    "./site-links": "./site-links.ts",
-    "./GoogleAnalytics": "./GoogleAnalytics.astro",
-    "./Analytics51LA": "./Analytics51LA.astro",
-    "./SEOHead": "./SEOHead.astro",
-    "./integration": "./integration.mjs",
-    "./seo-utils": "./seo-utils.mjs",
-    "./rss-locales": "./rss-locales.mjs",
-    "./rss": "./rss-renderer.mjs",
-    "./seo-schema": {
-      "types": "./seo-schema.d.ts",
-      "default": "./seo-schema.mjs"
-    }
+    "./integration": {
+      "types": "./dist/integration.d.ts",
+      "default": "./dist/integration.js"
+    },
+    "./SEOHead": "./SEOHead.astro"
   },
   "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
     "*.astro",
-    "*.png",
-    "*.ico",
-    "*.mjs",
-    "*.ts",
-    "*.json"
+    "robots.txt.ts",
+    "rss*.xml.ts"
   ],
   "peerDependencies": {
     "astro": "^6.0.7 || ^7.3.5"
   },
+  "devDependencies": {
+    "astro": "^7.3.5"
+  },
   "dependencies": {
-    "@astrojs/rss": "^4.0.19",
-    "@astrojs/sitemap": "^3.7.4"
+    "@astrojs/sitemap": "^3.7.4",
+    "@hagicode/hagilight-core": "0.3.2-dev.57.1.ee1f17e"
   },
   "keywords": [
     "astro-component",
+    "astro-integration",
     "withastro",
     "astro-components",
-    "starlight",
     "documentation-components"
   ]
 }

package/rss.[language].xml.ts

@@ -1,6 +1,6 @@
 import type { APIRoute, GetStaticPaths } from 'astro';
 import rssConfig from 'virtual:hagilight/rss-config';
-import { renderRssFeed } from './rss-runtime.mjs';
+import { renderRssFeed } from './dist/rss-runtime.js';
 
 export const getStaticPaths: GetStaticPaths = () => [...new Set([
   'en',

package/rss.xml.ts

@@ -1,5 +1,5 @@
 import type { APIRoute } from 'astro';
 import rssConfig from 'virtual:hagilight/rss-config';
-import { renderRssFeed } from './rss-runtime.mjs';
+import { renderRssFeed } from './dist/rss-runtime.js';
 
 export const GET: APIRoute = () => renderRssFeed(rssConfig, 'en');

package/Analytics51LA.astro

@@ -1,17 +0,0 @@
----
-interface Props {
-  siteId: string;
-}
-
-const { siteId } = Astro.props;
-if (!siteId?.trim()) throw new Error('Analytics51LA requires a siteId prop.');
----
-
-{import.meta.env.PROD && (
-  <>
-    <script is:inline charset="UTF-8" id="LA_COLLECT" src="https://sdk.51.la/js-sdk-pro.min.js"></script>
-    <script is:inline define:vars={{ siteId }}>
-      LA.init({ id: siteId, ck: siteId, autoTrack: true, hashMode: true, screenRecord: true });
-    </script>
-  </>
-)}

package/Copyright.astro

@@ -1,9 +0,0 @@
----
-interface Props {
-  name: string;
-}
-
-const { name } = Astro.props;
----
-
-<span>© {new Date().getFullYear()} {name}</span>

package/Footer.astro

@@ -1,157 +0,0 @@
----
-import Copyright from './Copyright.astro';
-import { resolveRssFooterLinks } from './rss-footer-context.mjs';
-import { resolveSiteLinks, type SiteLinksOptions } from './site-links.ts';
-
-interface Props {
-  locale?: string;
-  links?: SiteLinksOptions;
-}
-
-const { locale: propLocale, links } = Astro.props;
-const locale = propLocale ?? Astro.currentLocale ?? 'en-US';
-const footerLinks = resolveRssFooterLinks(Astro.locals, locale, links);
-const resolvedLinks = resolveSiteLinks(locale, footerLinks);
----
-
-<footer class="hagilight-footer">
-  <div class="hagilight-footer__sections">
-    {resolvedLinks.relatedSites.length > 0 && (
-      <section>
-        <h2>{resolvedLinks.labels.relatedSites}</h2>
-        <nav aria-label={resolvedLinks.labels.navigation.relatedSites}>
-          <ul>
-            {resolvedLinks.relatedSites.map((site) => (
-              <li>
-                <a href={site.href} target={site.target} rel={site.rel}>{site.name}</a>
-              </li>
-            ))}
-          </ul>
-        </nav>
-      </section>
-    )}
-    <section>
-      <h2>{resolvedLinks.labels.quickLinks}</h2>
-      <nav aria-label={resolvedLinks.labels.navigation.quickLinks}>
-        <ul>
-          {resolvedLinks.quick.map((link) => (
-            <li>
-              <a
-                href={link.href}
-                target={link.target}
-                rel={link.rel}
-                aria-label={link.ariaLabel}
-              >{link.label}</a>
-            </li>
-          ))}
-        </ul>
-      </nav>
-    </section>
-    <section>
-      <h2>{resolvedLinks.labels.community}</h2>
-      <nav aria-label={resolvedLinks.labels.navigation.community}>
-        <ul>
-          {resolvedLinks.community.map((link) => (
-            <li>
-              <a
-                href={link.href}
-                target={link.target}
-                rel={link.rel}
-                aria-label={link.ariaLabel}
-              >{link.label}</a>
-            </li>
-          ))}
-        </ul>
-      </nav>
-    </section>
-  </div>
-  <nav class="hagilight-footer__filings" aria-label={resolvedLinks.labels.navigation.filings}>
-    {resolvedLinks.filings.map((link) => (
-      <a
-        href={link.href}
-        target={link.target}
-        rel={link.rel}
-        aria-label={link.ariaLabel}
-      >{link.label}</a>
-    ))}
-  </nav>
-  <p class="hagilight-footer__copyright"><Copyright name="HagiCode" /></p>
-</footer>
-
-<style>
-  .hagilight-footer {
-    border-top: 1px solid var(--hagilight-footer-border, currentColor);
-    color: var(--hagilight-footer-color, inherit);
-    padding: 1.5rem 1rem 1rem;
-  }
-
-  .hagilight-footer__sections {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(min(100%, 12rem), 1fr));
-    gap: 1.5rem;
-    margin: 0 auto 1.5rem;
-    max-width: 72rem;
-  }
-
-  .hagilight-footer section {
-    min-width: 0;
-  }
-
-  .hagilight-footer h2 {
-    margin: 0 0 0.75rem;
-    font-size: 0.95rem;
-    font-weight: 650;
-  }
-
-  .hagilight-footer ul {
-    display: grid;
-    gap: 0.5rem;
-    margin: 0;
-    padding: 0;
-    list-style: none;
-  }
-
-  .hagilight-footer a {
-    color: inherit;
-    text-decoration: none;
-    text-underline-offset: 0.2em;
-  }
-
-  .hagilight-footer a:hover {
-    text-decoration: underline;
-  }
-
-  .hagilight-footer a:focus-visible {
-    border-radius: 0.125rem;
-    outline: 2px solid currentColor;
-    outline-offset: 0.2rem;
-  }
-
-  .hagilight-footer__filings {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.75rem 1.5rem;
-    border-top: 1px solid var(--hagilight-footer-border, currentColor);
-    padding-top: 1rem;
-    text-align: center;
-  }
-
-  .hagilight-footer__copyright {
-    margin: 1rem 0 0;
-    font-size: 0.8rem;
-    text-align: center;
-  }
-
-  @media (max-width: 40rem) {
-    .hagilight-footer__sections {
-      grid-template-columns: 1fr;
-      gap: 1.25rem;
-    }
-
-    .hagilight-footer__filings {
-      justify-content: flex-start;
-      gap: 0.75rem 1rem;
-    }
-  }
-</style>