@jk2908/solas 0.4.4 → 0.5.1

package/dist/internal/prerender.js

@@ -4,6 +4,7 @@ import { BasePath } from '../utils/base-path.js';
 import { Logger } from '../utils/logger.js';
 import { Solas } from '../solas.js';
 import { toPathPattern } from './http-router/utils.js';
+import { Runtime as AdapterRuntime } from './runtimes/runtime.js';
 const logger = new Logger();
 export { Prerender };
 var Prerender;
@@ -60,18 +61,18 @@ var Prerender;
          * Load the postponed state for a given route from the file system, if it exists
          */
         async function loadPostponedState(outDir, pathname) {
-            let file;
+            let filePath;
             try {
-                file = Bun.file(path.join(getPath(outDir, pathname), 'postponed.json'));
+                filePath = path.join(getPath(outDir, pathname), 'postponed.json');
             }
             catch (err) {
                 logger.warn(`[prerender:artifacts] rejected postponed state path for ${pathname}`, Logger.print(err));
                 return null;
             }
-            if (!(await file.exists()))
+            if (!(await AdapterRuntime.exists(filePath)))
                 return null;
             try {
-                return JSON.parse(await file.text());
+                return JSON.parse(await AdapterRuntime.readText(filePath));
             }
             catch {
                 return null;
@@ -82,18 +83,18 @@ var Prerender;
          * Load the prelude HTML for a given route from the file system, if it exists
          */
         async function loadPrelude(outDir, pathname) {
-            let file;
+            let filePath;
             try {
-                file = Bun.file(path.join(getPath(outDir, pathname), 'prelude.html'));
+                filePath = path.join(getPath(outDir, pathname), 'prelude.html');
             }
             catch (err) {
                 logger.warn(`[prerender:artifacts] rejected prelude path for ${pathname}`, Logger.print(err));
                 return null;
             }
-            if (!(await file.exists()))
+            if (!(await AdapterRuntime.exists(filePath)))
                 return null;
             try {
-                return await file.text();
+                return await AdapterRuntime.readText(filePath);
             }
             catch {
                 return null;
@@ -104,18 +105,18 @@ var Prerender;
          * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
          */
         async function loadMetadata(outDir, pathname) {
-            let file;
+            let filePath;
             try {
-                file = Bun.file(path.join(getPath(outDir, pathname), 'metadata.json'));
+                filePath = path.join(getPath(outDir, pathname), 'metadata.json');
             }
             catch (err) {
                 logger.warn(`[prerender:artifacts] rejected metadata path for ${pathname}`, Logger.print(err));
                 return null;
             }
-            if (!(await file.exists()))
+            if (!(await AdapterRuntime.exists(filePath)))
                 return null;
             try {
-                const value = JSON.parse(await file.text());
+                const value = JSON.parse(await AdapterRuntime.readText(filePath));
                 if (!value || typeof value !== 'object')
                     return null;
                 const schema = value.schema;
@@ -270,7 +271,7 @@ var Prerender;
             const params = await buildContext.exportReader.value(filePath, 'params', (v) => typeof v === 'function');
             if (!params)
                 return [];
-            const resolved = await Promise.try(() => params());
+            const resolved = await Promise.resolve().then(() => params());
             if (!Array.isArray(resolved))
                 return [];
             return resolved;

package/dist/internal/runtimes/bun.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeBase } from './runtime.js';
+export declare class RuntimeBun extends RuntimeBase {
+    exists(filePath: string): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Promise<ArrayBuffer>;
+    mimeType(filePath: string): string;
+    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    hash(value: string): string;
+}

package/dist/internal/runtimes/bun.js

@@ -0,0 +1,33 @@
+import { RuntimeBase } from './runtime.js';
+export class RuntimeBun extends RuntimeBase {
+    async exists(filePath) {
+        return Bun.file(filePath).exists();
+    }
+    readText(filePath) {
+        return Bun.file(filePath).text();
+    }
+    readBuffer(filePath) {
+        return Bun.file(filePath).arrayBuffer();
+    }
+    mimeType(filePath) {
+        return Bun.file(filePath).type || 'application/octet-stream';
+    }
+    async write(filePath, content) {
+        // normalise wider arraybuffer views into a shape Bun.write accepts directly
+        await Bun.write(filePath, typeof content === 'string'
+            ? content
+            : content instanceof Uint8Array
+                ? content
+                : new Uint8Array(content.buffer, content.byteOffset, content.byteLength));
+    }
+    hash(value) {
+        const hash = Bun.hash(value);
+        // Bun.hash returns an integer-like value, so keep it in BigInt space and avoid
+        // precision loss. Clamp it to an unsigned 64-bit value before hex
+        // formatting. Pad to 16 chars to match the Node runtime
+        // output shape
+        return BigInt.asUintN(64, typeof hash === 'bigint' ? hash : BigInt(hash))
+            .toString(16)
+            .padStart(16, '0');
+    }
+}

package/dist/internal/runtimes/mime.d.ts

@@ -0,0 +1 @@
+export declare function getMimeTypeFromPath(filePath: string): string;

package/dist/internal/runtimes/mime.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+const MIME_BY_EXT = {
+    '.txt': 'text/plain; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.cjs': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.xml': 'application/xml; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.pdf': 'application/pdf',
+    '.wasm': 'application/wasm',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.ogg': 'audio/ogg',
+};
+export function getMimeTypeFromPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_BY_EXT[ext] ?? 'application/octet-stream';
+}

package/dist/internal/runtimes/node.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeBase } from './runtime.js';
+export declare class RuntimeNode extends RuntimeBase {
+    exists(filePath: string): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Promise<ArrayBuffer>;
+    mimeType(filePath: string): string;
+    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    hash(value: string): string;
+}

package/dist/internal/runtimes/node.js

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import { getMimeTypeFromPath } from './mime.js';
+import { RuntimeBase } from './runtime.js';
+export class RuntimeNode extends RuntimeBase {
+    async exists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    readText(filePath) {
+        return fs.readFile(filePath, 'utf-8');
+    }
+    async readBuffer(filePath) {
+        const buffer = await fs.readFile(filePath);
+        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    }
+    mimeType(filePath) {
+        return getMimeTypeFromPath(filePath);
+    }
+    async write(filePath, content) {
+        await fs.writeFile(filePath, content);
+    }
+    hash(value) {
+        return createHash('sha256').update(value).digest('hex').slice(0, 16);
+    }
+}

package/dist/internal/runtimes/runtime.d.ts

@@ -0,0 +1,29 @@
+export declare namespace Runtime {
+    type Impl = {
+        exists: (filePath: string) => Promise<boolean>;
+        readText: (filePath: string) => Promise<string>;
+        readBuffer: (filePath: string) => Promise<ArrayBuffer>;
+        mimeType: (filePath: string) => string;
+        write: (filePath: string, content: string | NodeJS.ArrayBufferView) => Promise<void>;
+        hash: (value: string) => string;
+    };
+}
+export declare abstract class RuntimeBase implements Runtime.Impl {
+    abstract exists(filePath: string): Promise<boolean>;
+    abstract readText(filePath: string): Promise<string>;
+    abstract readBuffer(filePath: string): Promise<ArrayBuffer>;
+    abstract mimeType(filePath: string): string;
+    abstract write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    abstract hash(value: string): string;
+}
+export declare class Runtime {
+    #private;
+    static set runtime(runtime: Runtime.Impl);
+    static get runtime(): Runtime.Impl;
+    static exists(filePath: string): Promise<boolean>;
+    static readText(filePath: string): Promise<string>;
+    static readBuffer(filePath: string): Promise<ArrayBuffer>;
+    static mimeType(filePath: string): string;
+    static write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    static hash(value: string): string;
+}

package/dist/internal/runtimes/runtime.js

@@ -0,0 +1,32 @@
+export class RuntimeBase {
+}
+export class Runtime {
+    static #runtime;
+    static set runtime(runtime) {
+        this.#runtime = runtime;
+    }
+    static get runtime() {
+        if (!this.#runtime) {
+            throw new Error('No runtime configured. Please set the runtime implementation before using runtime methods.');
+        }
+        return this.#runtime;
+    }
+    static exists(filePath) {
+        return this.runtime.exists(filePath);
+    }
+    static readText(filePath) {
+        return this.runtime.readText(filePath);
+    }
+    static readBuffer(filePath) {
+        return this.runtime.readBuffer(filePath);
+    }
+    static mimeType(filePath) {
+        return this.runtime.mimeType(filePath);
+    }
+    static write(filePath, content) {
+        return this.runtime.write(filePath, content);
+    }
+    static hash(value) {
+        return this.runtime.hash(value);
+    }
+}

package/dist/runtimes/bun.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeBase } from '../internal/runtimes/runtime.js';
+declare class BunAdapter extends RuntimeBase {
+    readonly name: "bun";
+    readonly module: string;
+    exists(filePath: string): Promise<boolean>;
+    readText(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Promise<ArrayBuffer>;
+    mimeType(filePath: string): string;
+    write(filePath: string, content: string | NodeJS.ArrayBufferView): Promise<void>;
+    hash(value: string): string;
+}
+export default function bunAdapter(): BunAdapter;
+export {};

package/dist/runtimes/bun.js

@@ -0,0 +1,39 @@
+import { RuntimeBase } from '../internal/runtimes/runtime.js';
+import { Solas } from '../solas.js';
+class BunAdapter extends RuntimeBase {
+    name = 'bun';
+    module = `${Solas.Config.PKG_NAME}/runtimes/bun`;
+    async exists(filePath) {
+        return Bun.file(filePath).exists();
+    }
+    readText(filePath) {
+        return Bun.file(filePath).text();
+    }
+    readBuffer(filePath) {
+        return Bun.file(filePath).arrayBuffer();
+    }
+    mimeType(filePath) {
+        return Bun.file(filePath).type || 'application/octet-stream';
+    }
+    async write(filePath, content) {
+        // normalise wider arraybuffer views into a shape Bun.write accepts directly
+        await Bun.write(filePath, typeof content === 'string'
+            ? content
+            : content instanceof Uint8Array
+                ? content
+                : new Uint8Array(content.buffer, content.byteOffset, content.byteLength));
+    }
+    hash(value) {
+        const hash = Bun.hash(value);
+        // Bun.hash returns an integer-like value, so keep it in BigInt space and avoid
+        // precision loss. Clamp it to an unsigned 64-bit value before hex
+        // formatting. Pad to 16 chars to match the Node adapter
+        // output shape
+        return BigInt.asUintN(64, typeof hash === 'bigint' ? hash : BigInt(hash))
+            .toString(16)
+            .padStart(16, '0');
+    }
+}
+export default function bunAdapter() {
+    return new BunAdapter();
+}

package/dist/solas.d.ts

@@ -1,5 +1,6 @@
 import type { Prerender } from './internal/prerender.js';
-import type { PluginConfig } from './types.js';
+import type { PluginConfig, Runtime } from './types.js';
+import { Runtime as InternalRuntime } from './internal/runtimes/runtime.js';
 export declare namespace Solas {
     interface Routes {
     }
@@ -18,6 +19,7 @@ export declare namespace Solas {
         const $: unique symbol;
         const REQUEST_META_KEY: string;
         const LOG_LEVELS: readonly ["debug", "info", "warn", "error", "fatal"];
+        const RUNTIMES: readonly ["auto", "node", "bun"];
         const PRERENDER_MODES: readonly ["full", "ppr", false];
         const TRAILING_SLASH_MODES: readonly ["always", "never", "ignore"];
         const RUNTIME_MANIFEST = "runtime-manifest.json";
@@ -34,6 +36,7 @@ export declare namespace Solas {
             artifacts: Prerender.Artifact.Manifest;
             publicFiles: ReadonlySet<string>;
         };
+        function create(runtime: Runtime): InternalRuntime.Impl;
         function getManifestPath(outDir: string): string;
         function loadManifest(outDir: string): Promise<Manifest | null>;
     }

package/dist/solas.js

@@ -1,3 +1,6 @@
+import { RuntimeBun } from './internal/runtimes/bun.js';
+import { RuntimeNode } from './internal/runtimes/node.js';
+import { Runtime as InternalRuntime } from './internal/runtimes/runtime.js';
 export { Solas };
 var Solas;
 (function (Solas) {
@@ -17,10 +20,12 @@ var Solas;
         Config.$ = Symbol(Config.SLUG);
         Config.REQUEST_META_KEY = `__${Config.SLUG.toUpperCase()}__`;
         Config.LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
+        Config.RUNTIMES = ['auto', 'node', 'bun'];
         Config.PRERENDER_MODES = ['full', 'ppr', false];
         Config.TRAILING_SLASH_MODES = ['always', 'never', 'ignore'];
         Config.RUNTIME_MANIFEST = 'runtime-manifest.json';
         const CONFIG_KEYS = new Set([
+            'runtime',
             'port',
             'logger',
             'metadata',
@@ -49,6 +54,11 @@ var Solas;
                     errors.push(`Unknown config key: ${key}`);
                 }
             }
+            if ('runtime' in input &&
+                input.runtime !== undefined &&
+                !isRuntime(input.runtime)) {
+                errors.push("config.runtime must be 'auto', 'node', or 'bun'");
+            }
             if ('url' in input && input.url !== undefined) {
                 if (typeof input.url !== 'string') {
                     errors.push('config.url must be a string');
@@ -161,6 +171,14 @@ var Solas;
     Solas.getVersion = getVersion;
     let Runtime;
     (function (Runtime) {
+        function create(runtime) {
+            if (runtime === 'bun' ||
+                (runtime === 'auto' && typeof globalThis.Bun !== 'undefined')) {
+                return new RuntimeBun();
+            }
+            return new RuntimeNode();
+        }
+        Runtime.create = create;
         const manifestCache = new Map();
         function getManifestPath(outDir) {
             return [outDir, Config.GENERATED_DIR, Config.RUNTIME_MANIFEST]
@@ -177,13 +195,13 @@ var Solas;
             if (manifestCache.has(outDir)) {
                 return manifestCache.get(outDir) ?? null;
             }
-            const file = Bun.file(getManifestPath(outDir));
-            if (!(await file.exists())) {
+            const manifestPath = getManifestPath(outDir);
+            if (!(await InternalRuntime.exists(manifestPath))) {
                 manifestCache.set(outDir, null);
                 return null;
             }
             try {
-                const value = JSON.parse(await file.text());
+                const value = JSON.parse(await InternalRuntime.readText(manifestPath));
                 if (!isRecord(value)) {
                     manifestCache.set(outDir, null);
                     return null;
@@ -230,12 +248,12 @@ var Solas;
                         return null;
                     }
                 }
-                const manifest = {
+                const runtimeManifest = {
                     artifacts: artifacts,
                     publicFiles: new Set(publicFiles ?? []),
                 };
-                manifestCache.set(outDir, manifest);
-                return manifest;
+                manifestCache.set(outDir, runtimeManifest);
+                return runtimeManifest;
             }
             catch {
                 manifestCache.set(outDir, null);
@@ -255,3 +273,6 @@ var Solas;
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isRuntime(value) {
+    return typeof value === 'string' && new Set(Solas.Config.RUNTIMES).has(value);
+}

package/dist/types.d.ts

@@ -9,8 +9,10 @@ import type { Metadata } from './internal/metadata.js';
 import type { HttpException } from './internal/navigation/http-exception.js';
 import { Solas } from './solas.js';
 export type LogLevel = (typeof Solas.Config.LOG_LEVELS)[number];
+export type Runtime = (typeof Solas.Config.RUNTIMES)[number];
 type Origin = `http://${string}` | `https://${string}`;
 type PluginConfigBase = {
+    runtime?: Runtime;
     port?: number;
     precompress?: boolean;
     prerender?: Route.Prerender;
@@ -30,7 +32,10 @@ export type PluginConfig = PluginConfigBase & ({
     url?: Origin;
     sitemap?: false;
 });
-export type RuntimeConfig = PluginConfig & {
+export type ConfiguredPluginConfig = PluginConfig & {
+    runtime: Runtime;
+};
+export type RuntimeConfig = Omit<PluginConfig, 'runtime'> & {
     precompress: NonNullable<PluginConfig['precompress']>;
     trailingSlash: NonNullable<PluginConfig['trailingSlash']>;
     trustedOrigins: NonNullable<PluginConfig['trustedOrigins']>;

package/dist/utils/compress.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { brotliCompress } from 'node:zlib';
+import { Runtime } from '../internal/runtimes/runtime.js';
 export { Compress };
 var Compress;
 (function (Compress) {
@@ -25,8 +26,7 @@ var Compress;
         return output;
     }
     async function compress(input) {
-        const file = Bun.file(input);
-        const buffer = Buffer.from(await file.arrayBuffer());
+        const buffer = Buffer.from(await Runtime.readBuffer(input));
         const compressed = await new Promise((fulfill, reject) => {
             brotliCompress(buffer, (err, res) => {
                 if (err) {

package/dist/utils/export-reader.js

@@ -1,9 +1,10 @@
+import fs from 'node:fs/promises';
 import path from 'node:path';
+import { parseSync, } from 'oxc-parser';
 export class ExportReader {
-    #transpilers = new Map();
     #loadModule = null;
     /**
-     * Pick the Bun loader type that matches the source file extension
+     * Pick the parser language that matches the source file extension
      */
     static #getLoaderType(filePath) {
         const ext = path.extname(filePath).toLowerCase();
@@ -17,28 +18,6 @@ export class ExportReader {
             return 'tsx';
         throw new Error(`Unsupported module extension: ${ext || '(none)'} in ${filePath}`);
     }
-    /**
-     * Parse a literal value from a string
-     */
-    static #parse(value) {
-        const trimmed = value.trim();
-        // keep quoted literals as strings without evaluating the
-        // source text
-        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-            (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
-            (trimmed.startsWith('`') && trimmed.endsWith('`'))) {
-            return trimmed.slice(1, -1);
-        }
-        if (trimmed === 'true')
-            return true;
-        if (trimmed === 'false')
-            return false;
-        if (trimmed === 'null')
-            return null;
-        const n = Number(trimmed);
-        if (Number.isFinite(n))
-            return n;
-    }
     /**
      * Set the Vite server's SSR module loader so we can execute modules
      */
@@ -46,30 +25,35 @@ export class ExportReader {
         this.#loadModule = l;
     }
     /**
-     * Reuse one transpiler per supported loader so scans match the module syntax
+     * Parse a source file as an ESM route module
      */
-    #getTranspiler(filePath) {
-        const type = ExportReader.#getLoaderType(filePath);
-        const cached = this.#transpilers.get(type);
-        if (cached)
-            return cached;
-        const transpiler = new Bun.Transpiler({ loader: type });
-        this.#transpilers.set(type, transpiler);
-        return transpiler;
+    async #parse(filePath) {
+        const source = await this.raw(filePath);
+        const result = parseSync(filePath, source, {
+            lang: ExportReader.#getLoaderType(filePath),
+            sourceType: 'module',
+            preserveParens: false,
+        });
+        if (result.errors.length > 0) {
+            throw new Error(result.errors[0]?.message ?? `Failed to parse ${filePath}`);
+        }
+        return result;
     }
     /**
      * Read the raw text content of a file
      */
     async raw(filePath) {
-        return Bun.file(filePath).text();
+        return fs.readFile(filePath, 'utf-8');
     }
     /**
      * Get the names of all exports from a file
      */
     async exports(filePath) {
-        // use Bun's transpiler scan so we can inspect export names
-        // without loading the module
-        return this.#getTranspiler(filePath).scan(await this.raw(filePath)).exports;
+        const { module } = await this.#parse(filePath);
+        return Array.from(new Set(module.staticExports.flatMap((entry) => entry.entries
+            .filter((specifier) => !specifier.isType)
+            .map((specifier) => specifier.exportName.name)
+            .filter((name) => typeof name === 'string' && name.length > 0))));
     }
     /**
      * Check if a file exports a specific name
@@ -86,27 +70,8 @@ export class ExportReader {
     async literal(filePath, name, validate) {
         if (!(await this.has(filePath, name)))
             return;
-        // transpile first so comments and type-only syntax do not confuse the
-        // literal matcher with exports that do not actually exist at runtime
-        const code = this.#getTranspiler(filePath).transformSync(await this.raw(filePath));
-        // build the matcher from escaped plain-text pieces so arbitrary export names
-        // cannot change the regex shape
-        const source = 
-        // match: `export const|let|var ` at statement boundaries
-        '(?:^|[;\\n])\\s*export\\s+(?:const|let|var)\\s+' +
-            // treat export name as plain text in regex
-            name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
-            // capture one supported literal value (string, number, boolean, null)
-            '\\s*=\\s*(?<value>(?:"(?:[^"\\\\]|\\\\.)*"|\'(?:[^\'\\\\]|\\\\.)*\'|\\x60(?:[^\\x60\\\\]|\\\\.)*\\x60|true|false|null|-?\\d+(?:\\.\\d+)?))(?=\\s|;|$)';
-        // multiline mode lets ^ match the start of each transpiled line, so the
-        // export regex stays anchored to a real statement boundary instead of
-        // the file start
-        const text = code.match(new RegExp(source, 'm'))?.groups?.value;
-        if (!text)
-            return;
-        // only support cheap literal parsing here. Anything richer should go through
-        // value() so module semantics stay correct
-        const value = ExportReader.#parse(text);
+        const { program } = await this.#parse(filePath);
+        const value = ExportReader.#readLiteralExport(program, name);
         if (value === undefined)
             return;
         if (!validate || validate(value))
@@ -130,4 +95,50 @@ export class ExportReader {
         if (!validate || validate(value))
             return value;
     }
+    static #readLiteralExport(program, name) {
+        for (const statement of program.body) {
+            if (statement.type !== 'ExportNamedDeclaration')
+                continue;
+            const declaration = statement.declaration;
+            if (!declaration || declaration.type !== 'VariableDeclaration')
+                continue;
+            for (const declarator of declaration.declarations) {
+                if (declarator.id.type !== 'Identifier' || declarator.id.name !== name)
+                    continue;
+                return ExportReader.#readLiteralValue(declarator.init);
+            }
+        }
+    }
+    static #readLiteralValue(value) {
+        if (!value || typeof value !== 'object' || !('type' in value))
+            return;
+        const node = value;
+        if (node.type === 'Literal') {
+            const literal = value;
+            if (typeof literal.value === 'string' ||
+                typeof literal.value === 'number' ||
+                typeof literal.value === 'boolean' ||
+                literal.value === null) {
+                return literal.value;
+            }
+        }
+        if (node.type === 'TemplateLiteral' &&
+            Array.isArray(value.expressions) &&
+            value.expressions.length === 0 &&
+            Array.isArray(value.quasis) &&
+            value.quasis.length === 1) {
+            const quasi = value.quasis[0];
+            if (quasi?.value && typeof quasi.value.cooked === 'string') {
+                return quasi.value.cooked;
+            }
+        }
+        if (node.type === 'UnaryExpression' &&
+            value.operator === '-' &&
+            value.argument.type === 'Literal' &&
+            value.argument.value !== null &&
+            typeof value.argument.value === 'number') {
+            const argument = value.argument.value;
+            return -argument;
+        }
+    }
 }