@zenithbuild/cli 0.6.13 → 0.7.0

package/dist/images/runtime.js

@@ -0,0 +1,254 @@
+import { buildLocalVariantPath, buildRemoteVariantPath, imageRuntimeGlobalName, matchRemotePattern, normalizeImageRuntimePayload, normalizeImageSource, resolveWidthCandidates } from './shared.js';
+function safeString(value) {
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return String(value);
+    }
+    return '';
+}
+function escapeHtml(value) {
+    return String(value || '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function buildAttr(name, value) {
+    if (value === null || value === undefined || value === '') {
+        return '';
+    }
+    return ` ${name}="${escapeHtml(value)}"`;
+}
+function readRuntimePayload() {
+    if (typeof globalThis !== 'object' || !globalThis) {
+        return null;
+    }
+    return normalizeImageRuntimePayload(globalThis[imageRuntimeGlobalName()]);
+}
+function encodeBase64(value) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(value, 'utf8').toString('base64');
+    }
+    if (typeof btoa === 'function' && typeof TextEncoder === 'function') {
+        const bytes = new TextEncoder().encode(value);
+        let binary = '';
+        for (const byte of bytes) {
+            binary += String.fromCharCode(byte);
+        }
+        return btoa(binary);
+    }
+    return '';
+}
+function decodeBase64(value) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(value, 'base64').toString('utf8');
+    }
+    if (typeof atob === 'function' && typeof TextDecoder === 'function') {
+        const binary = atob(value);
+        const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    return '';
+}
+function encodeMarkerPayload(value) {
+    return encodeBase64(JSON.stringify(value));
+}
+function decodeMarkerPayload(value) {
+    try {
+        const json = decodeBase64(String(value || ''));
+        const parsed = JSON.parse(json);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function localEntryFor(payload, publicPath) {
+    if (!payload || !payload.localImages || typeof payload.localImages !== 'object') {
+        return null;
+    }
+    return payload.localImages[publicPath] || null;
+}
+function pickNumeric(value, fallback) {
+    return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function mergeStyle(style, fit, position) {
+    const segments = [];
+    const incoming = safeString(style);
+    if (incoming) {
+        segments.push(incoming.replace(/;+\s*$/, ''));
+    }
+    if (safeString(fit)) {
+        segments.push(`object-fit: ${safeString(fit)}`);
+    }
+    if (safeString(position)) {
+        segments.push(`object-position: ${safeString(position)}`);
+    }
+    return segments.join('; ');
+}
+function buildSourceTags(sources) {
+    return sources.map((entry) => {
+        const attrs = [
+            buildAttr('type', entry.type),
+            buildAttr('srcset', entry.srcset),
+            buildAttr('sizes', entry.sizes)
+        ].join('');
+        return `<source${attrs}>`;
+    }).join('');
+}
+function mimeTypeForFormat(format) {
+    switch (String(format || '').toLowerCase()) {
+        case 'avif':
+            return 'image/avif';
+        case 'webp':
+            return 'image/webp';
+        case 'png':
+            return 'image/png';
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        default:
+            return '';
+    }
+}
+function buildLocalImageModel(props, payload, source) {
+    const config = payload?.config;
+    const manifestEntry = localEntryFor(payload, source.path);
+    const width = pickNumeric(props.width, pickNumeric(source.width, pickNumeric(manifestEntry?.width, null)));
+    const height = pickNumeric(props.height, pickNumeric(source.height, pickNumeric(manifestEntry?.height, null)));
+    const quality = pickNumeric(props.quality, config.quality);
+    const sizes = safeString(props.sizes);
+    const widths = resolveWidthCandidates(width, sizes, config, manifestEntry);
+    const fallbackFormat = safeString(manifestEntry?.originalFormat) || 'jpg';
+    const sourceFormats = (config.formats || []).filter((format) => Array.isArray(manifestEntry?.availableFormats)
+        ? manifestEntry.availableFormats.includes(format)
+        : true);
+    const fallbackWidth = widths.length > 0 ? widths[widths.length - 1] : width;
+    const imgSrc = props.unoptimized === true
+        ? source.path
+        : buildLocalVariantPath(source.path, fallbackWidth || width || manifestEntry?.width || 0, quality, fallbackFormat);
+    const sources = props.unoptimized === true
+        ? []
+        : sourceFormats.map((format) => ({
+            type: mimeTypeForFormat(format),
+            sizes,
+            srcset: widths.map((candidate) => `${buildLocalVariantPath(source.path, candidate, quality, format)} ${candidate}w`).join(', ')
+        })).filter((entry) => entry.type && entry.srcset);
+    return {
+        src: imgSrc,
+        width,
+        height,
+        sizes,
+        sources
+    };
+}
+function buildRemoteImageModel(props, payload, source) {
+    const config = payload?.config;
+    const width = pickNumeric(props.width, pickNumeric(source.width, null));
+    const height = pickNumeric(props.height, pickNumeric(source.height, null));
+    const quality = pickNumeric(props.quality, config.quality);
+    const sizes = safeString(props.sizes);
+    const widths = resolveWidthCandidates(width, sizes, config, null);
+    const allowed = matchRemotePattern(source.url, config.remotePatterns || []);
+    if (!allowed) {
+        return null;
+    }
+    if (payload.mode !== 'endpoint' || props.unoptimized === true || !width) {
+        return {
+            src: source.url,
+            width,
+            height,
+            sizes,
+            sources: []
+        };
+    }
+    const sources = (config.formats || []).map((format) => ({
+        type: mimeTypeForFormat(format),
+        sizes,
+        srcset: widths.map((candidate) => `${buildRemoteVariantPath(source.url, candidate, quality, format)} ${candidate}w`).join(', ')
+    })).filter((entry) => entry.type && entry.srcset);
+    return {
+        src: buildRemoteVariantPath(source.url, widths[widths.length - 1] || width, quality, ''),
+        width,
+        height,
+        sizes,
+        sources
+    };
+}
+export function renderImageHtmlWithPayload(rawProps, payload) {
+    const props = rawProps && typeof rawProps === 'object' ? rawProps : {};
+    const source = normalizeImageSource(props.src);
+    if (!source) {
+        return '';
+    }
+    const alt = safeString(props.alt) || safeString(source.alt);
+    if (!alt) {
+        return '';
+    }
+    const model = source.kind === 'local'
+        ? buildLocalImageModel(props, payload, source)
+        : buildRemoteImageModel(props, payload, source);
+    if (!model || !model.src) {
+        return '';
+    }
+    const className = safeString(props.class);
+    const style = mergeStyle(props.style, props.fit, props.position);
+    const loading = props.priority === true ? 'eager' : safeString(props.loading) || 'lazy';
+    const decoding = safeString(props.decoding) || 'async';
+    const fetchPriority = props.priority === true ? 'high' : '';
+    const sourcesHtml = buildSourceTags(model.sources);
+    const imgAttrs = [
+        buildAttr('src', model.src),
+        buildAttr('alt', alt),
+        buildAttr('class', className),
+        buildAttr('style', style),
+        buildAttr('loading', loading),
+        buildAttr('decoding', decoding),
+        buildAttr('fetchpriority', fetchPriority),
+        buildAttr('sizes', model.sizes),
+        buildAttr('width', model.width),
+        buildAttr('height', model.height)
+    ].join('');
+    if (sourcesHtml) {
+        return `<picture>${sourcesHtml}<img${imgAttrs} /></picture>`;
+    }
+    return `<img${imgAttrs} />`;
+}
+export function renderImageHtml(rawProps) {
+    const payload = readRuntimePayload();
+    if (!payload) {
+        return '';
+    }
+    return renderImageHtmlWithPayload(rawProps, payload);
+}
+export function serializeImageProps(rawProps) {
+    const props = rawProps && typeof rawProps === 'object' ? rawProps : {};
+    const source = normalizeImageSource(props.src);
+    const alt = safeString(props.alt) || safeString(source?.alt);
+    if (!source || !alt) {
+        return '';
+    }
+    return encodeMarkerPayload({
+        ...props,
+        src: props.src
+    });
+}
+export function replaceImageMarkers(html, payload) {
+    if (typeof html !== 'string' || html.length === 0) {
+        return html;
+    }
+    const runtimePayload = normalizeImageRuntimePayload(payload);
+    if (!runtimePayload) {
+        return html;
+    }
+    return html.replace(/(<span\b[^>]*\bdata-zenith-image=(["'])([^"']+)\2[^>]*>)([\s\S]*?)<\/span>/gi, (_match, openTag, _quote, encodedPayload) => {
+        const props = decodeMarkerPayload(encodedPayload);
+        if (!props) {
+            return `${openTag}</span>`;
+        }
+        return `${openTag}${renderImageHtmlWithPayload(props, runtimePayload)}</span>`;
+    });
+}

package/dist/images/service.d.ts

@@ -0,0 +1,4 @@
+export function buildImageArtifacts(options: any): Promise<{
+    manifest: {};
+}>;
+export function handleImageRequest(req: any, res: any, options: any): Promise<boolean>;

package/dist/images/service.js

@@ -0,0 +1,302 @@
+import { lookup } from 'node:dns/promises';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, stat, writeFile, readdir } from 'node:fs/promises';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import sharp from 'sharp';
+import { buildLocalImageKey, buildLocalVariantPath, matchRemotePattern, normalizeImageConfig, normalizeImageFormat } from './shared.js';
+const RASTER_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp', '.avif']);
+const MIME_BY_FORMAT = {
+    avif: 'image/avif',
+    webp: 'image/webp',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg'
+};
+function isPrivateIp(address) {
+    if (!address) {
+        return false;
+    }
+    if (address === '::1' || address === '127.0.0.1') {
+        return true;
+    }
+    if (address.startsWith('10.') || address.startsWith('192.168.')) {
+        return true;
+    }
+    if (/^172\.(1[6-9]|2\d|3[0-1])\./.test(address)) {
+        return true;
+    }
+    if (/^(fc|fd)/i.test(address.replace(/:/g, ''))) {
+        return true;
+    }
+    return false;
+}
+function isLoopbackHostname(hostname) {
+    const normalized = String(hostname || '').toLowerCase();
+    return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1';
+}
+function mimeTypeForFormat(format) {
+    return MIME_BY_FORMAT[normalizeImageFormat(format)] || 'application/octet-stream';
+}
+function uniqueSortedWidths(config, metadataWidth) {
+    const values = new Set([
+        ...(config.deviceSizes || []),
+        ...(config.imageSizes || [])
+    ]);
+    if (Number.isInteger(metadataWidth) && metadataWidth > 0) {
+        values.add(metadataWidth);
+    }
+    return [...values]
+        .filter((value) => Number.isInteger(value) && value > 0)
+        .filter((value) => !metadataWidth || value <= metadataWidth)
+        .sort((left, right) => left - right);
+}
+function resolvePublicRoots(projectRoot) {
+    const candidates = [
+        resolve(projectRoot, 'src', 'public'),
+        resolve(projectRoot, 'public')
+    ];
+    return candidates.filter((candidate, index) => existsSync(candidate) && candidates.indexOf(candidate) === index);
+}
+async function walkPublicImages(rootDir) {
+    const files = [];
+    async function walk(dir) {
+        let entries = [];
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+                continue;
+            }
+            const extension = extname(entry.name).toLowerCase();
+            if (RASTER_EXTENSIONS.has(extension)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+async function writeIfStale(sourcePath, targetPath, buffer) {
+    const sourceInfo = await stat(sourcePath);
+    if (existsSync(targetPath)) {
+        const targetInfo = await stat(targetPath);
+        if (targetInfo.mtimeMs >= sourceInfo.mtimeMs) {
+            return;
+        }
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, buffer);
+}
+function variantRelativePath(publicPath, width, quality, format) {
+    return buildLocalVariantPath(publicPath, width, quality, format).replace(/^\//, '');
+}
+function createRemoteCacheKey(url, width, quality, format) {
+    return buildLocalImageKey(`${url}|${width}|${quality}|${format || 'original'}`);
+}
+async function transformImageBuffer(buffer, width, quality, format) {
+    let pipeline = sharp(buffer, { animated: false }).rotate();
+    if (Number.isInteger(width) && width > 0) {
+        pipeline = pipeline.resize({ width, withoutEnlargement: true });
+    }
+    switch (normalizeImageFormat(format)) {
+        case 'avif':
+            return pipeline.avif({ quality }).toBuffer();
+        case 'webp':
+            return pipeline.webp({ quality }).toBuffer();
+        case 'png':
+            return pipeline.png({ quality }).toBuffer();
+        case 'jpg':
+        case 'jpeg':
+            return pipeline.jpeg({ quality }).toBuffer();
+        default:
+            return pipeline.toBuffer();
+    }
+}
+export async function buildImageArtifacts(options) {
+    const { projectRoot, outDir, config: rawConfig } = options;
+    const config = normalizeImageConfig(rawConfig);
+    const manifest = {};
+    const publicRoots = resolvePublicRoots(projectRoot);
+    if (publicRoots.length === 0) {
+        return { manifest };
+    }
+    for (const publicRoot of publicRoots) {
+        const files = await walkPublicImages(publicRoot);
+        for (const filePath of files) {
+            const publicPath = `/${relative(publicRoot, filePath).replaceAll('\\', '/')}`;
+            if (manifest[publicPath]) {
+                continue;
+            }
+            const image = sharp(filePath, { animated: false });
+            const metadata = await image.metadata();
+            if (!Number.isInteger(metadata.width) || !Number.isInteger(metadata.height) || !metadata.format) {
+                continue;
+            }
+            const widths = uniqueSortedWidths(config, metadata.width);
+            const originalFormat = normalizeImageFormat(metadata.format);
+            const formats = [...new Set([originalFormat, ...config.formats])];
+            const quality = config.quality;
+            const key = buildLocalImageKey(publicPath);
+            manifest[publicPath] = {
+                key,
+                width: metadata.width,
+                height: metadata.height,
+                originalFormat,
+                availableWidths: widths,
+                availableFormats: formats
+            };
+            const sourceBuffer = await readFile(filePath);
+            for (const width of widths) {
+                for (const format of formats) {
+                    const buffer = await transformImageBuffer(sourceBuffer, width, quality, format);
+                    const outputPath = join(outDir, variantRelativePath(publicPath, width, quality, format));
+                    await writeIfStale(filePath, outputPath, buffer);
+                }
+            }
+        }
+    }
+    const manifestPath = join(outDir, '_zenith', 'image', 'manifest.json');
+    await mkdir(dirname(manifestPath), { recursive: true });
+    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    return { manifest };
+}
+async function validateRemoteTarget(remoteUrl, config) {
+    const url = new URL(remoteUrl);
+    if (!matchRemotePattern(url, config.remotePatterns)) {
+        throw new Error('[Zenith:Image] Remote URL is not allowed by images.remotePatterns');
+    }
+    if (!config.dangerouslyAllowLocalNetwork) {
+        if (isLoopbackHostname(url.hostname)) {
+            throw new Error('[Zenith:Image] Loopback and local network image fetches are blocked');
+        }
+        const resolved = await lookup(url.hostname, { all: true });
+        if (resolved.some((entry) => isPrivateIp(entry.address))) {
+            throw new Error('[Zenith:Image] Private network image fetches are blocked');
+        }
+    }
+    return url;
+}
+async function readRemoteBuffer(response, maxBytes) {
+    const reader = response.body?.getReader?.();
+    if (!reader) {
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.length > maxBytes) {
+            throw new Error('[Zenith:Image] Remote image exceeds maxRemoteBytes');
+        }
+        return buffer;
+    }
+    let total = 0;
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        total += value.byteLength;
+        if (total > maxBytes) {
+            throw new Error('[Zenith:Image] Remote image exceeds maxRemoteBytes');
+        }
+        chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks);
+}
+function sendBuffer(res, status, contentType, buffer, cacheSeconds) {
+    res.writeHead(status, {
+        'Content-Type': contentType,
+        'Cache-Control': `public, max-age=${cacheSeconds}`
+    });
+    res.end(buffer);
+}
+function remoteCachePaths(cacheDir, cacheKey) {
+    return {
+        dataPath: join(cacheDir, `${cacheKey}.img`),
+        metaPath: join(cacheDir, `${cacheKey}.json`)
+    };
+}
+export async function handleImageRequest(req, res, options) {
+    const { requestUrl, projectRoot, config: rawConfig } = options;
+    const config = normalizeImageConfig(rawConfig);
+    const url = requestUrl instanceof URL ? requestUrl : new URL(String(requestUrl));
+    const remoteUrl = url.searchParams.get('url');
+    const width = Number.parseInt(url.searchParams.get('w') || '', 10);
+    const requestedQuality = Number.parseInt(url.searchParams.get('q') || '', 10);
+    const format = normalizeImageFormat(url.searchParams.get('f') || '');
+    const quality = Number.isInteger(requestedQuality) && requestedQuality > 0 ? requestedQuality : config.quality;
+    if (!remoteUrl) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'missing_url' }));
+        return true;
+    }
+    if (!Number.isInteger(width) || width <= 0) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'invalid_width' }));
+        return true;
+    }
+    try {
+        const remote = await validateRemoteTarget(remoteUrl, config);
+        const cacheKey = createRemoteCacheKey(remote.toString(), width, quality, format || 'original');
+        const cacheDir = resolve(projectRoot, '.zenith', 'image-cache');
+        const { dataPath, metaPath } = remoteCachePaths(cacheDir, cacheKey);
+        if (existsSync(dataPath) && existsSync(metaPath)) {
+            const [cached, cachedMeta] = await Promise.all([
+                readFile(dataPath),
+                readFile(metaPath, 'utf8')
+            ]);
+            const parsedMeta = JSON.parse(cachedMeta);
+            const contentType = typeof parsedMeta?.contentType === 'string'
+                ? parsedMeta.contentType
+                : mimeTypeForFormat(format || 'jpg');
+            sendBuffer(res, 200, contentType, cached, config.minimumCacheTTL);
+            return true;
+        }
+        const response = await fetch(remote, {
+            headers: {
+                'Accept': 'image/avif,image/webp,image/png,image/jpeg,image/*;q=0.8,*/*;q=0.1'
+            },
+            redirect: 'follow'
+        });
+        if (!response.ok) {
+            throw new Error(`[Zenith:Image] Remote image fetch failed with status ${response.status}`);
+        }
+        const contentType = String(response.headers.get('content-type') || '').toLowerCase();
+        if (!contentType.startsWith('image/')) {
+            throw new Error('[Zenith:Image] Remote response was not an image');
+        }
+        if (contentType.includes('svg') && !config.allowSvg) {
+            throw new Error('[Zenith:Image] SVG images are blocked unless images.allowSvg is enabled');
+        }
+        const buffer = await readRemoteBuffer(response, config.maxRemoteBytes);
+        const metadata = await sharp(buffer, { animated: false }).metadata();
+        if ((metadata.width || 0) * (metadata.height || 0) > config.maxPixels) {
+            throw new Error('[Zenith:Image] Remote image exceeds maxPixels');
+        }
+        const sourceFormat = normalizeImageFormat(metadata.format);
+        const targetFormat = format || (sourceFormat === 'gif' ? 'png' : sourceFormat || 'jpg');
+        const output = await transformImageBuffer(buffer, width, quality, targetFormat);
+        await mkdir(cacheDir, { recursive: true });
+        await Promise.all([
+            writeFile(dataPath, output),
+            writeFile(metaPath, `${JSON.stringify({
+                contentType: mimeTypeForFormat(targetFormat),
+                format: targetFormat
+            }, null, 2)}\n`, 'utf8')
+        ]);
+        sendBuffer(res, 200, mimeTypeForFormat(targetFormat), output, config.minimumCacheTTL);
+        return true;
+    }
+    catch (error) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error: 'image_request_failed',
+            message: error instanceof Error ? error.message : String(error)
+        }));
+        return true;
+    }
+}

package/dist/images/shared.d.ts

@@ -0,0 +1,58 @@
+export function normalizeImageConfig(input: any): {
+    formats: string[];
+    deviceSizes: number[];
+    imageSizes: number[];
+    remotePatterns: any[];
+    quality: number;
+    allowSvg: boolean;
+    maxRemoteBytes: number;
+    maxPixels: number;
+    minimumCacheTTL: number;
+    dangerouslyAllowLocalNetwork: boolean;
+};
+export function matchRemotePattern(inputUrl: any, patterns: any): boolean;
+export function isRemoteImageUrl(value: any): boolean;
+export function normalizeImageSource(input: any): any;
+export function normalizeImageFormat(value: any): string;
+export function buildLocalImageKey(publicPath: any): string;
+export function buildLocalVariantPath(publicPath: any, width: any, quality: any, format: any): string;
+export function buildRemoteVariantPath(remoteUrl: any, width: any, quality: any, format: any): string;
+export function resolveWidthCandidates(width: any, sizes: any, config: any, manifestEntry: any): any[];
+export function imageRuntimeGlobalName(): string;
+export function normalizeImageRuntimePayload(payload: any): {
+    mode: string;
+    config: {
+        formats: string[];
+        deviceSizes: number[];
+        imageSizes: number[];
+        remotePatterns: any[];
+        quality: number;
+        allowSvg: boolean;
+        maxRemoteBytes: number;
+        maxPixels: number;
+        minimumCacheTTL: number;
+        dangerouslyAllowLocalNetwork: boolean;
+    };
+    localImages: any;
+} | null;
+export namespace DEFAULT_IMAGE_CONFIG {
+    export { DEFAULT_FORMATS as formats };
+    export { DEFAULT_QUALITY as quality };
+    export { DEFAULT_DEVICE_SIZES as deviceSizes };
+    export { DEFAULT_IMAGE_SIZES as imageSizes };
+    export { DEFAULT_REMOTE_PATTERNS as remotePatterns };
+    export let allowSvg: boolean;
+    export { DEFAULT_MAX_REMOTE_BYTES as maxRemoteBytes };
+    export { DEFAULT_MAX_PIXELS as maxPixels };
+    export { DEFAULT_MINIMUM_CACHE_TTL as minimumCacheTTL };
+    export let dangerouslyAllowLocalNetwork: boolean;
+}
+declare const DEFAULT_FORMATS: string[];
+declare const DEFAULT_QUALITY: 75;
+declare const DEFAULT_DEVICE_SIZES: number[];
+declare const DEFAULT_IMAGE_SIZES: number[];
+declare const DEFAULT_REMOTE_PATTERNS: any[];
+declare const DEFAULT_MAX_REMOTE_BYTES: number;
+declare const DEFAULT_MAX_PIXELS: 40000000;
+declare const DEFAULT_MINIMUM_CACHE_TTL: 60;
+export {};