@vivliostyle/cli 8.17.0 → 9.0.0-next.0

package/dist/config/resolve.js

@@ -0,0 +1,727 @@
+import { VFM } from '@vivliostyle/vfm';
+import { lookup as mime } from 'mime-types';
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import upath from 'upath';
+import { getExecutableBrowserPath } from '../browser.js';
+import { COVER_HTML_FILENAME, COVER_HTML_IMAGE_ALT, EPUB_OUTPUT_VERSION, MANIFEST_FILENAME, TOC_FILENAME, TOC_TITLE, } from '../const.js';
+import { CONTAINER_IMAGE, CONTAINER_LOCAL_HOSTNAME } from '../container.js';
+import { Logger } from '../logger.js';
+import { readMarkdownMetadata } from '../processor/markdown.js';
+import { parsePackageName } from '../processor/theme.js';
+import { cwd as defaultCwd, getEpubRootDir, isInContainer, isValidUri, pathEquals, readJSON, statFileSync, touchTmpFile, } from '../util.js';
+export const manuscriptMediaTypes = [
+    'text/markdown',
+    'text/html',
+    'application/xhtml+xml',
+];
+const DEFAULT_ASSET_EXTENSIONS = [
+    'png',
+    'jpg',
+    'jpeg',
+    'svg',
+    'gif',
+    'webp',
+    'apng',
+    'ttf',
+    'otf',
+    'woff',
+    'woff2',
+];
+function isManuscriptMediaType(mediaType) {
+    return !!(mediaType && manuscriptMediaTypes.includes(mediaType));
+}
+export function isWebPubConfig(config) {
+    return config.viewerInput.type === 'webpub';
+}
+// parse theme locator
+export function parseTheme({ theme, context, workspaceDir, themesDir, }) {
+    const { specifier, import: importPath } = typeof theme === 'string' ? { specifier: theme, import: undefined } : theme;
+    // url
+    if (isValidUri(specifier)) {
+        return {
+            type: 'uri',
+            name: upath.basename(specifier),
+            location: specifier,
+        };
+    }
+    // bare .css file
+    const stylePath = upath.resolve(context, specifier);
+    if (fs.existsSync(stylePath) && stylePath.endsWith('.css')) {
+        const sourceRelPath = upath.relative(context, stylePath);
+        return {
+            type: 'file',
+            name: upath.basename(specifier),
+            source: stylePath,
+            location: upath.resolve(workspaceDir, sourceRelPath),
+        };
+    }
+    // node_modules, local pkg
+    const parsed = parsePackageName(specifier, context);
+    if (!parsed) {
+        throw new Error(`Invalid package name: ${specifier}`);
+    }
+    // To security reason, Vivliostyle CLI disallow other than npm registry or local file as download source
+    // TODO: Add option that user can allow an unofficial registry explicitly
+    if (!parsed.registry && parsed.type !== 'directory') {
+        throw new Error(`This package specifier is not allowed: ${specifier}`);
+    }
+    let name = parsed.name;
+    let resolvedSpecifier = specifier;
+    if (parsed.type === 'directory' && parsed.fetchSpec) {
+        const pkgJsonPath = upath.join(parsed.fetchSpec, 'package.json');
+        if (fs.existsSync(pkgJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+            name = packageJson.name;
+            resolvedSpecifier = parsed.fetchSpec;
+        }
+    }
+    if (!name) {
+        throw new Error(`Could not determine the package name: ${specifier}`);
+    }
+    return {
+        type: 'package',
+        name,
+        specifier: resolvedSpecifier,
+        location: upath.join(themesDir, 'node_modules', name),
+        importPath,
+    };
+}
+function parsePageSize(size) {
+    const [width, height, ...others] = `${size}`.split(',');
+    if (!width || others.length) {
+        throw new Error(`Cannot parse size: ${size}`);
+    }
+    else if (width && height) {
+        return {
+            width,
+            height,
+        };
+    }
+    else {
+        return {
+            format: width,
+        };
+    }
+}
+function parseFileMetadata({ contentType, sourcePath, workspaceDir, themesDir, }) {
+    const sourceDir = upath.dirname(sourcePath);
+    let title;
+    let themes;
+    if (contentType === 'text/markdown') {
+        const metadata = readMarkdownMetadata(sourcePath);
+        title = metadata.title;
+        if (metadata.vfm?.theme && themesDir) {
+            themes = [metadata.vfm.theme]
+                .flat()
+                .filter((entry) => !!entry && (typeof entry === 'string' || typeof entry === 'object'))
+                .map((theme) => parseTheme({
+                theme,
+                context: sourceDir,
+                workspaceDir,
+                themesDir,
+            }));
+        }
+    }
+    else {
+        const content = fs.readFileSync(sourcePath, 'utf8');
+        title = content.match(/<title>([^<]*)<\/title>/)?.[1] || undefined;
+    }
+    return { title, themes };
+}
+export function resolveTaskConfig(config, options) {
+    const context = options.cwd ?? defaultCwd;
+    Logger.debug('context directory', context);
+    Logger.debug('inlineOptions', options);
+    Logger.debug('vivliostyle.config.js', config);
+    const entryContextDir = config.entryContext
+        ? upath.resolve(context, config.entryContext)
+        : context;
+    const language = config.language;
+    const readingProgression = config.readingProgression;
+    const size = config.size ? parsePageSize(config.size) : undefined;
+    const cropMarks = options.cropMarks ?? false;
+    const bleed = options.bleed;
+    const cropOffset = options.cropOffset;
+    const css = options.css;
+    const customStyle = options.style &&
+        (isValidUri(options.style)
+            ? options.style
+            : pathToFileURL(options.style).href);
+    const customUserStyle = options.userStyle &&
+        (isValidUri(options.userStyle)
+            ? options.userStyle
+            : pathToFileURL(options.userStyle).href);
+    const singleDoc = options.singleDoc ?? false;
+    const quick = options.quick ?? false;
+    const temporaryFilePrefix = config.temporaryFilePrefix ?? `.vs-${Date.now()}.`;
+    const documentProcessorFactory = config?.documentProcessor ?? VFM;
+    const vfmOptions = {
+        ...config?.vfm,
+        hardLineBreaks: config?.vfm?.hardLineBreaks ?? false,
+        disableFormatHtml: config?.vfm?.disableFormatHtml ?? false,
+    };
+    const timeout = config.timeout ?? 120_000; // 2 minutes
+    const sandbox = options.sandbox ?? false;
+    const browserType = config.browser ?? 'chromium';
+    const proxyServer = options.proxyServer ?? process.env.HTTP_PROXY ?? undefined;
+    const proxy = proxyServer
+        ? {
+            server: proxyServer,
+            bypass: options.proxyBypass ?? process.env.NOPROXY ?? undefined,
+            username: options.proxyUser,
+            password: options.proxyPass,
+        }
+        : undefined;
+    const executableBrowser = options.executableBrowser ?? getExecutableBrowserPath(browserType);
+    const image = config.image ?? CONTAINER_IMAGE;
+    const viewer = config.viewer ?? undefined;
+    const viewerParam = config.viewerParam ?? undefined;
+    const logLevel = options.logLevel ?? 'silent';
+    const ignoreHttpsErrors = options.ignoreHttpsErrors ?? false;
+    const base = config.base ?? '/vivliostyle';
+    const staticRoutes = config.static ?? {};
+    const viteConfig = config.vite;
+    const viteConfigFile = config.viteConfigFile ?? true;
+    const outputs = (() => {
+        const defaultPdfOptions = {
+            format: 'pdf',
+            renderMode: 'local',
+            preflight: config.pressReady ? 'press-ready' : undefined,
+            preflightOption: [],
+        };
+        if (config.output) {
+            return config.output.map((target) => {
+                const outputPath = upath.resolve(context, target.path);
+                const format = target.format;
+                switch (format) {
+                    case 'pdf':
+                        return {
+                            ...defaultPdfOptions,
+                            ...target,
+                            format,
+                            path: outputPath,
+                        };
+                    case 'epub':
+                        return {
+                            ...target,
+                            format,
+                            path: outputPath,
+                            version: EPUB_OUTPUT_VERSION,
+                        };
+                    case 'webpub':
+                        return {
+                            ...target,
+                            format,
+                            path: outputPath,
+                        };
+                    default:
+                        return format;
+                }
+            });
+        }
+        // Outputs a pdf file if any output configuration is not set
+        const filename = config.title ? `${config.title}.pdf` : 'output.pdf';
+        return [
+            {
+                ...defaultPdfOptions,
+                path: upath.resolve(context, filename),
+            },
+        ];
+    })();
+    const { server, rootUrl } = (() => {
+        let host = config.server?.host ?? false;
+        const port = config.server?.port ?? 13000;
+        if (outputs.some((target) => target.format === 'pdf' && target.renderMode === 'docker')) {
+            // Docker render mode requires wildcard host to allow access from the container
+            host = true;
+        }
+        const rootHostname = isInContainer()
+            ? CONTAINER_LOCAL_HOSTNAME
+            : !host
+                ? 'localhost'
+                : host === true
+                    ? '0.0.0.0'
+                    : host;
+        return {
+            server: {
+                host,
+                port,
+                proxy: config.server?.proxy ?? {},
+            },
+            rootUrl: `http://${rootHostname}:${port}`,
+        };
+    })();
+    const cover = config.cover && {
+        src: upath.resolve(entryContextDir, config.cover.src),
+        name: config.cover.name || COVER_HTML_IMAGE_ALT,
+    };
+    const copyAsset = {
+        includes: config.copyAsset?.includes ?? config.includeAssets ?? [],
+        excludes: config.copyAsset?.excludes ?? [],
+        fileExtensions: [
+            ...new Set([
+                ...DEFAULT_ASSET_EXTENSIONS,
+                ...(config.copyAsset?.includeFileExtensions ?? []),
+            ]),
+        ].filter((ext) => !(config.copyAsset?.excludeFileExtensions ?? []).includes(ext)),
+    };
+    const themeIndexes = new Set();
+    const projectConfig = !options.config && options.input
+        ? resolveSingleInputConfig({
+            config,
+            input: options.input,
+            context,
+            temporaryFilePrefix,
+            themeIndexes,
+        })
+        : resolveComposedProjectConfig({
+            config,
+            context,
+            entryContextDir,
+            outputs,
+            temporaryFilePrefix,
+            themeIndexes,
+            rootUrl,
+            cover,
+        });
+    const resolvedConfig = {
+        ...projectConfig,
+        context,
+        entryContextDir,
+        outputs,
+        themeIndexes,
+        copyAsset,
+        temporaryFilePrefix,
+        size,
+        cropMarks,
+        bleed,
+        cropOffset,
+        css,
+        customStyle,
+        customUserStyle,
+        singleDoc,
+        quick,
+        language,
+        readingProgression,
+        documentProcessorFactory,
+        vfmOptions,
+        cover,
+        timeout,
+        sandbox,
+        executableBrowser,
+        browserType,
+        proxy,
+        image,
+        viewer,
+        viewerParam,
+        logLevel,
+        ignoreHttpsErrors,
+        base,
+        server,
+        static: staticRoutes,
+        rootUrl,
+        viteConfig,
+        viteConfigFile,
+    };
+    Logger.debug('resolvedConfig', JSON.stringify(resolvedConfig, null, 2));
+    return resolvedConfig;
+}
+function resolveSingleInputConfig({ config, input, context, temporaryFilePrefix, themeIndexes, }) {
+    Logger.debug('entering single entry config mode');
+    let sourcePath;
+    let workspaceDir;
+    const inputFormat = input.format;
+    const title = config?.title;
+    const author = config?.author;
+    const entries = [];
+    const exportAliases = [];
+    if (isValidUri(input.entry)) {
+        sourcePath = input.entry;
+        workspaceDir = context;
+    }
+    else {
+        sourcePath = upath.resolve(context, input.entry);
+        // Check file exists
+        statFileSync(sourcePath);
+        switch (input.format) {
+            case 'webbook':
+                workspaceDir = context;
+                break;
+            case 'markdown':
+            case 'pub-manifest':
+            case 'epub':
+                workspaceDir = upath.dirname(sourcePath);
+                break;
+            case 'epub-opf': {
+                const rootDir = getEpubRootDir(sourcePath);
+                if (!rootDir) {
+                    throw new Error(`Could not determine the EPUB root directory for the OPF file: ${sourcePath}`);
+                }
+                workspaceDir = rootDir;
+                break;
+            }
+            default:
+                return input.format;
+        }
+    }
+    const themesDir = upath.resolve(workspaceDir, 'themes');
+    if (input.format === 'markdown') {
+        // Single input file; create temporary file
+        const contentType = 'text/markdown';
+        const metadata = parseFileMetadata({
+            contentType,
+            sourcePath,
+            workspaceDir,
+        });
+        const relDir = upath.relative(context, upath.dirname(sourcePath));
+        const target = upath
+            .resolve(workspaceDir, relDir, `${temporaryFilePrefix}${upath.basename(sourcePath)}`)
+            .replace(/\.md$/, '.html');
+        touchTmpFile(target);
+        const themes = metadata.themes ??
+            config.theme?.map((theme) => parseTheme({
+                theme,
+                context,
+                workspaceDir,
+                themesDir,
+            })) ??
+            [];
+        themes.forEach((t) => themeIndexes.add(t));
+        entries.push({
+            contentType,
+            source: {
+                type: 'file',
+                pathname: sourcePath,
+                contentType,
+            },
+            target,
+            title: metadata.title,
+            themes,
+        });
+        exportAliases.push({
+            source: target,
+            target: upath.resolve(upath.dirname(target), upath.basename(sourcePath).replace(/\.md$/, '.html')),
+        });
+    }
+    let fallbackTitle;
+    let viewerInput;
+    if (inputFormat === 'markdown') {
+        // create temporary manifest file
+        const manifestPath = upath.resolve(workspaceDir, `${temporaryFilePrefix}${MANIFEST_FILENAME}`);
+        touchTmpFile(manifestPath);
+        exportAliases.push({
+            source: manifestPath,
+            target: upath.resolve(workspaceDir, MANIFEST_FILENAME),
+        });
+        fallbackTitle =
+            entries.length === 1 && entries[0].title
+                ? entries[0].title
+                : upath.basename(sourcePath);
+        viewerInput = {
+            type: 'webpub',
+            manifestPath,
+            needToGenerateManifest: true,
+        };
+    }
+    else if (inputFormat === 'webbook') {
+        const url = isValidUri(sourcePath)
+            ? new URL(sourcePath)
+            : pathToFileURL(sourcePath);
+        // Ensures trailing slash or explicit HTML extensions
+        if (/^https?:/i.test(url.protocol) &&
+            !url.pathname.endsWith('/') &&
+            !/\.html?$/.test(url.pathname)) {
+            url.pathname = `${url.pathname}/`;
+        }
+        viewerInput = { type: 'webbook', webbookEntryUrl: url.href };
+    }
+    else if (inputFormat === 'pub-manifest') {
+        viewerInput = {
+            type: 'webpub',
+            manifestPath: sourcePath,
+            needToGenerateManifest: false,
+        };
+    }
+    else if (inputFormat === 'epub-opf') {
+        viewerInput = { type: 'epub-opf', epubOpfPath: sourcePath };
+    }
+    else if (inputFormat === 'epub') {
+        viewerInput = {
+            type: 'epub',
+            epubPath: sourcePath,
+            epubTmpOutputDir: upath.join(sourcePath, `../${temporaryFilePrefix}${upath.basename(sourcePath)}`),
+        };
+    }
+    else {
+        return inputFormat;
+    }
+    return {
+        workspaceDir,
+        themesDir,
+        entries,
+        input: {
+            format: inputFormat,
+            entry: sourcePath,
+        },
+        viewerInput,
+        exportAliases,
+        title: title || fallbackTitle,
+        author,
+    };
+}
+function resolveComposedProjectConfig({ config, context, entryContextDir, outputs, temporaryFilePrefix, themeIndexes, rootUrl, cover, }) {
+    Logger.debug('entering composed project config mode');
+    const workspaceDir = upath.resolve(context, config.workspaceDir ?? '.vivliostyle');
+    const themesDir = upath.resolve(workspaceDir, 'themes');
+    const pkgJsonPath = upath.resolve(entryContextDir, 'package.json');
+    const pkgJson = fs.existsSync(pkgJsonPath)
+        ? readJSON(pkgJsonPath)
+        : undefined;
+    if (pkgJson) {
+        Logger.debug('located package.json path', pkgJsonPath);
+    }
+    const exportAliases = [];
+    const rootThemes = config.theme?.map((theme) => parseTheme({
+        theme,
+        context,
+        workspaceDir,
+        themesDir,
+    })) ?? [];
+    const tocConfig = {
+        tocTitle: config.toc?.title ?? config?.tocTitle ?? TOC_TITLE,
+        target: upath.resolve(workspaceDir, config.toc?.htmlPath ?? TOC_FILENAME),
+        sectionDepth: config.toc?.sectionDepth ?? 0,
+        transform: {
+            transformDocumentList: config.toc?.transformDocumentList,
+            transformSectionList: config.toc?.transformSectionList,
+        },
+    };
+    const coverHtml = config.cover &&
+        ('htmlPath' in config.cover && !config.cover.htmlPath
+            ? undefined
+            : upath.resolve(workspaceDir, config.cover?.htmlPath || COVER_HTML_FILENAME));
+    const ensureCoverImage = (src) => {
+        const absPath = src && upath.resolve(entryContextDir, src);
+        if (absPath) {
+            statFileSync(absPath, {
+                errorMessage: 'Specified cover image does not exist',
+            });
+        }
+        return absPath;
+    };
+    const projectTitle = config?.title ?? pkgJson?.name;
+    const projectAuthor = config?.author ?? pkgJson?.author;
+    const isContentsEntry = (entry) => entry.rel === 'contents';
+    const isCoverEntry = (entry) => entry.rel === 'cover';
+    const isArticleEntry = (entry) => !isContentsEntry(entry) && !isCoverEntry(entry);
+    function parseEntry(entry) {
+        const getInputInfo = (entryPath) => {
+            if (/^https?:/.test(entryPath)) {
+                return {
+                    type: 'uri',
+                    href: entryPath,
+                    rootDir: upath.join(workspaceDir, new URL(entryPath).host),
+                };
+            }
+            else if (entryPath.startsWith('/')) {
+                return {
+                    type: 'uri',
+                    href: `${rootUrl}${entryPath}`,
+                    rootDir: upath.join(workspaceDir, 'localhost'),
+                };
+            }
+            const pathname = upath.resolve(entryContextDir, entryPath);
+            statFileSync(pathname);
+            const contentType = mime(pathname);
+            if (!isManuscriptMediaType(contentType)) {
+                throw new Error(`Invalid manuscript type ${contentType} detected: ${entry}`);
+            }
+            return {
+                type: 'file',
+                pathname,
+                contentType,
+                metadata: parseFileMetadata({
+                    contentType,
+                    sourcePath: pathname,
+                    workspaceDir,
+                    themesDir,
+                }),
+            };
+        };
+        const getTargetPath = (source) => {
+            switch (source.type) {
+                case 'file':
+                    return upath.resolve(workspaceDir, upath
+                        .relative(entryContextDir, source.pathname)
+                        .replace(/\.md$/, '.html'));
+                case 'uri': {
+                    const url = new URL(source.href, 'a://dummy');
+                    let pathname = url.pathname;
+                    if (!/\.html?$/.test(pathname)) {
+                        pathname = `${pathname.replace(/\/$/, '')}/index.html`;
+                    }
+                    return upath.join(source.rootDir, pathname);
+                }
+                default:
+                    return source;
+            }
+        };
+        if ((isContentsEntry(entry) || isCoverEntry(entry)) && entry.path) {
+            const source = upath.resolve(entryContextDir, entry.path);
+            try {
+                statFileSync(source);
+                /* v8 ignore next 10 */
+            }
+            catch (error) {
+                // For backward compatibility, we allow missing files then assume that option as `output` field.
+                Logger.logWarn(`The "path" option is set but the file does not exist: ${source}\nMaybe you want to set the "output" field instead.`);
+                entry.output = entry.path;
+                entry.path = undefined;
+            }
+        }
+        if (isContentsEntry(entry)) {
+            const inputInfo = entry.path ? getInputInfo(entry.path) : undefined;
+            const { metadata, ...template } = inputInfo || {};
+            let target = entry.output
+                ? upath.resolve(workspaceDir, entry.output)
+                : inputInfo && getTargetPath(inputInfo);
+            const themes = entry.theme
+                ? [entry.theme].flat().map((theme) => parseTheme({
+                    theme,
+                    context,
+                    workspaceDir,
+                    themesDir,
+                }))
+                : (metadata?.themes ?? [...rootThemes]);
+            themes.forEach((t) => themeIndexes.add(t));
+            target ??= tocConfig.target;
+            if (inputInfo?.type === 'file' &&
+                pathEquals(inputInfo.pathname, target)) {
+                const tmpPath = upath.resolve(upath.dirname(target), `${temporaryFilePrefix}${upath.basename(target)}`);
+                exportAliases.push({ source: tmpPath, target });
+                touchTmpFile(tmpPath);
+                target = tmpPath;
+            }
+            const parsedEntry = {
+                rel: 'contents',
+                ...tocConfig,
+                target,
+                title: entry.title ?? metadata?.title ?? projectTitle,
+                themes,
+                pageBreakBefore: entry.pageBreakBefore,
+                pageCounterReset: entry.pageCounterReset,
+                ...('type' in template && { template }),
+            };
+            return parsedEntry;
+        }
+        if (isCoverEntry(entry)) {
+            const inputInfo = entry.path ? getInputInfo(entry.path) : undefined;
+            const { metadata, ...template } = inputInfo || {};
+            let target = entry.output
+                ? upath.resolve(workspaceDir, entry.output)
+                : inputInfo && getTargetPath(inputInfo);
+            const themes = entry.theme
+                ? [entry.theme].flat().map((theme) => parseTheme({
+                    theme,
+                    context,
+                    workspaceDir,
+                    themesDir,
+                }))
+                : (metadata?.themes ?? []); // Don't inherit rootThemes for cover documents
+            themes.forEach((t) => themeIndexes.add(t));
+            const coverImageSrc = ensureCoverImage(entry.imageSrc || cover?.src);
+            if (!coverImageSrc) {
+                throw new Error(`A CoverEntryConfig is set in the entry list but a location of cover file is not set. Please set 'cover' property in your config file.`);
+            }
+            target ??= upath.resolve(workspaceDir, entry.path || coverHtml || COVER_HTML_FILENAME);
+            if (inputInfo?.type === 'file' &&
+                pathEquals(inputInfo.pathname, target)) {
+                const tmpPath = upath.resolve(upath.dirname(target), `${temporaryFilePrefix}${upath.basename(target)}`);
+                exportAliases.push({ source: tmpPath, target });
+                touchTmpFile(tmpPath);
+                target = tmpPath;
+            }
+            const parsedEntry = {
+                rel: 'cover',
+                target,
+                title: entry.title ?? metadata?.title ?? projectTitle,
+                themes,
+                coverImageSrc,
+                coverImageAlt: entry.imageAlt || cover?.name || COVER_HTML_IMAGE_ALT,
+                pageBreakBefore: entry.pageBreakBefore,
+                ...('type' in template && { template }),
+            };
+            return parsedEntry;
+        }
+        if (isArticleEntry(entry)) {
+            const inputInfo = getInputInfo(entry.path);
+            const { metadata, ...source } = inputInfo;
+            const target = entry.output
+                ? upath.resolve(workspaceDir, entry.output)
+                : getTargetPath(inputInfo);
+            const themes = entry.theme
+                ? [entry.theme]
+                    .flat()
+                    .map((theme) => parseTheme({ theme, context, workspaceDir, themesDir }))
+                : (metadata?.themes ?? [...rootThemes]);
+            themes.forEach((t) => themeIndexes.add(t));
+            const parsedEntry = {
+                contentType: inputInfo.type === 'file' ? inputInfo.contentType : 'text/html',
+                source,
+                target,
+                title: entry.title ?? metadata?.title ?? projectTitle,
+                themes,
+                ...(entry.rel && { rel: entry.rel }),
+            };
+            return parsedEntry;
+        }
+        /* v8 ignore next */
+        return entry;
+    }
+    const entries = config.entry.map(parseEntry);
+    let fallbackProjectTitle;
+    if (!projectTitle) {
+        if (entries.length === 1 && entries[0].title) {
+            fallbackProjectTitle = entries[0].title;
+        }
+        else {
+            fallbackProjectTitle = upath.basename(outputs[0].path);
+        }
+    }
+    if (!!config?.toc && !entries.find(({ rel }) => rel === 'contents')) {
+        entries.unshift({
+            rel: 'contents',
+            ...tocConfig,
+            themes: [...rootThemes],
+        });
+    }
+    if (cover && coverHtml && !entries.find(({ rel }) => rel === 'cover')) {
+        entries.unshift({
+            rel: 'cover',
+            target: coverHtml,
+            title: projectTitle,
+            themes: [], // Don't inherit rootThemes for cover documents
+            coverImageSrc: ensureCoverImage(cover.src),
+            coverImageAlt: cover.name,
+        });
+    }
+    return {
+        workspaceDir,
+        themesDir,
+        entries,
+        input: {
+            format: 'pub-manifest',
+            entry: upath.join(workspaceDir, MANIFEST_FILENAME),
+        },
+        viewerInput: {
+            type: 'webpub',
+            manifestPath: upath.join(workspaceDir, MANIFEST_FILENAME),
+            needToGenerateManifest: true,
+        },
+        exportAliases,
+        title: projectTitle || fallbackProjectTitle,
+        author: projectAuthor,
+    };
+}
+//# sourceMappingURL=resolve.js.map