ghost 6.60.0 → 6.62.0

package/core/server/services/content-import/import/completion-email.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buildCompletionEmail;
+const report_1 = __importDefault(require("./report"));
+const errors_file_1 = __importDefault(require("./errors-file"));
+const { slugify } = require('@tryghost/string');
+const IMPORTED_POST_PREVIEW_LIMIT = 10;
+function escapeHTML(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function countsFor(run) {
+    const counts = {
+        created: 0,
+        updated: 0,
+        skipped: 0,
+        failed: 0,
+        warningRows: 0,
+    };
+    for (const row of run.rows) {
+        counts[row.status] += 1;
+        if (row.warnings?.length) {
+            counts.warningRows += 1;
+        }
+    }
+    return counts;
+}
+function headingFor(run, counts) {
+    if (run.status === 'failed') {
+        return 'Your content import could not be completed';
+    }
+    if (counts.failed > 0 && counts.created + counts.updated === 0) {
+        return 'Your content import was unsuccessful';
+    }
+    return 'Your content import is complete';
+}
+function formatNumber(value) {
+    return value.toLocaleString();
+}
+function summaryItems(counts, hasErrorsFile) {
+    const items = [
+        ['Created', counts.created],
+        ['Updated', counts.updated],
+        ['Skipped', counts.skipped],
+        ['Failed', counts.failed],
+    ];
+    return items
+        .map(([label, count]) => {
+        const attachmentCopy = label === 'Failed' && hasErrorsFile ? ' (see attached errors.csv)' : '';
+        return `<li style="margin-bottom: 6px;"><strong>${label}:</strong> ${formatNumber(count)}${attachmentCopy}</li>`;
+    })
+        .join('');
+}
+function importTagSlug(runId) {
+    // Internal tag slugs replace the leading # with "hash-" in the model layer.
+    return slugify(`#Import Run ${runId}`.replace(/^#/, 'hash-'));
+}
+function importedPostLinks(run, adminUrl) {
+    const importedRows = run.rows.filter((row) => row.status === 'created' || row.status === 'updated');
+    if (!importedRows.length) {
+        return '';
+    }
+    const rows = importedRows.filter((row) => row.url);
+    const previewRows = rows.slice(0, IMPORTED_POST_PREVIEW_LIMIT);
+    const hasPages = importedRows.some((row) => row.postType === 'page');
+    const hasPosts = importedRows.some((row) => row.postType !== 'page');
+    const links = previewRows
+        .map((row) => {
+        const title = escapeHTML(row.title || `Row ${row.line}`);
+        return `<li style="margin-bottom: 6px;"><a href="${escapeHTML(row.url)}" style="color: #3A464C;">${title}</a></li>`;
+    })
+        .join('');
+    const remaining = importedRows.length - previewRows.length;
+    const remainingCopy = remaining
+        ? `<p style="font-size: 16px; line-height: 25px; color: #3A464C;">Including ${formatNumber(remaining)} more.</p>`
+        : '';
+    const tag = encodeURIComponent(importTagSlug(run.id));
+    const postsUrl = escapeHTML(new URL(`#/posts?tag=${tag}`, adminUrl).href);
+    const pagesUrl = escapeHTML(new URL(`#/pages?tag=${tag}`, adminUrl).href);
+    let heading = 'Imported posts';
+    if (hasPages) {
+        heading = hasPosts ? 'Imported posts and pages' : 'Imported pages';
+    }
+    const filteredLinks = [
+        hasPosts ? `<a href="${postsUrl}" style="color: #3A464C;">View imported posts</a>` : '',
+        hasPages ? `<a href="${pagesUrl}" style="color: #3A464C;">View imported pages</a>` : '',
+    ]
+        .filter(Boolean)
+        .join(' · ');
+    const preview = links
+        ? `<ul style="font-size: 16px; line-height: 25px; color: #3A464C; padding-left: 24px;">${links}</ul>`
+        : '';
+    return `<h2 style="color: #15212A; font-size: 18px; line-height: 24px; margin: 32px 0 12px;">${heading}</h2>
+      ${preview}
+      ${remainingCopy}
+      <p style="font-size: 16px; line-height: 25px; color: #3A464C;">${filteredLinks}</p>`;
+}
+function renderCompletionEmail(run, recipient, adminUrl, hasErrorsFile) {
+    const counts = countsFor(run);
+    const heading = headingFor(run, counts);
+    const warningCopy = counts.warningRows
+        ? `<p style="font-size: 16px; line-height: 25px; color: #3A464C;"><strong>${formatNumber(counts.warningRows)}</strong> ${counts.warningRows === 1 ? 'post has' : 'posts have'} warnings.</p>`
+        : '';
+    const failureCopy = run.status === 'failed'
+        ? '<p style="font-size: 16px; line-height: 25px; color: #3A464C;">Something went wrong on our end before the import could finish. There is nothing wrong with your file, and it is safe to try again.</p>'
+        : '';
+    const escapedRecipient = escapeHTML(recipient);
+    return `<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width">
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>${heading}</title>
+  </head>
+  <body style="background-color: #ffffff; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif; color: #3A464C; margin: 0; padding: 0;">
+    <div style="box-sizing: border-box; margin: 0 auto; max-width: 540px; padding: 40px 20px;">
+      <img src="https://static.ghost.org/v4.0.0/images/ghost-orb-4.png" width="60" height="60" alt="Ghost" style="display: block; margin: 0 auto 40px;" />
+      <h1 style="color: #15212A; font-size: 21px; line-height: 25px; margin: 0 0 24px;">${heading}</h1>
+      ${failureCopy}
+      <p style="font-size: 16px; line-height: 25px; color: #3A464C;">The import processed ${formatNumber(run.total)} ${run.total === 1 ? 'row' : 'rows'}:</p>
+      <ul style="font-size: 16px; line-height: 25px; color: #3A464C; padding-left: 24px;">${summaryItems(counts, hasErrorsFile)}</ul>
+      ${warningCopy}
+      ${importedPostLinks(run, adminUrl)}
+      <p style="color: #738A94; font-size: 11px; line-height: 18px; margin-top: 64px;">This email was sent to <a href="mailto:${escapedRecipient}" style="color: #738A94;">${escapedRecipient}</a>.</p>
+    </div>
+  </body>
+</html>`;
+}
+function buildCompletionEmail(run, recipient, adminUrl) {
+    const counts = countsFor(run);
+    const report = (0, report_1.default)(run);
+    const errorsFile = (0, errors_file_1.default)(run);
+    const attachments = [];
+    if (report) {
+        attachments.push({
+            filename: 'report.csv',
+            content: report,
+            contentType: 'text/csv',
+            contentDisposition: 'attachment',
+        });
+    }
+    if (errorsFile) {
+        attachments.push({
+            filename: 'errors.csv',
+            content: errorsFile,
+            contentType: 'text/csv',
+            contentDisposition: 'attachment',
+        });
+    }
+    return {
+        to: recipient,
+        subject: headingFor(run, counts),
+        html: renderCompletionEmail(run, recipient, adminUrl, Boolean(errorsFile)),
+        forceTextContent: true,
+        attachments,
+    };
+}

package/core/server/services/content-import/import/errors-file.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buildErrorsFile;
+const csv_1 = require("../csv");
+const ANNOTATION_NAMES = ['import_status', 'import_reason', 'import_media_failures'];
+function isActionable(row) {
+    return Boolean(row.source) && row.status === 'failed';
+}
+function uniqueColumnName(preferred, used) {
+    let candidate = preferred;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${preferred}_${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function buildErrorsFile(run) {
+    const rows = run.rows.filter(isActionable);
+    if (!rows.length) {
+        return undefined;
+    }
+    const usedColumns = new Set(run.sourceColumns);
+    const [outcomeColumn, reasonColumn, mediaFailuresColumn] = ANNOTATION_NAMES.map((name) => uniqueColumnName(name, usedColumns));
+    const columns = [outcomeColumn, reasonColumn, mediaFailuresColumn, ...run.sourceColumns];
+    return (0, csv_1.serialize)(rows.map((row) => {
+        const sourceCells = Object.fromEntries(run.sourceColumns.map((column) => [column, row.source?.[column] ?? '']));
+        return {
+            ...sourceCells,
+            [outcomeColumn]: row.status,
+            [reasonColumn]: row.reason ?? '',
+            [mediaFailuresColumn]: row.mediaFailures?.length ? JSON.stringify(row.mediaFailures) : '',
+        };
+    }), { columns });
+}

package/core/server/services/content-import/import/importer.js

@@ -38,6 +38,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const post_data_1 = __importStar(require("./post-data"));
+const media_1 = require("./media");
+const content_csv_import_job_1 = __importDefault(require("../jobs/content-csv-import-job"));
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
 const tpl = require('@tryghost/tpl');
@@ -45,11 +47,11 @@ const messages = {
     unreadableFile: 'The file could not be parsed as a CSV file.',
     tooManyPosts: 'This file contains more than {max} posts. Imports are temporarily limited to {max} posts at a time — please split the file into smaller files and try again.',
     allWritesFailed: 'Content import failed to write all {count} attempted {postNoun}.',
-    urlResolutionFailed: 'Content import could not resolve a URL for {count} created {postNoun}.',
+    urlResolutionFailed: 'Content import could not resolve a URL for {count} imported {postNoun}.',
 };
 function logLifecycle(message) {
     try {
-        logging.info(`[Background Job] content-import ${message}`);
+        logging.info(`[Background Job] ${content_csv_import_job_1.default.type} ${message}`);
     }
     catch {
         // Observability must not change whether an import is queued or resolves.
@@ -64,24 +66,32 @@ function buildImportTagNames(runId, timezone, now) {
 }
 class ContentCSVImporter {
     _readRows;
+    _prepareSource;
     _posts;
     _getHtmlToLexical;
     _getMarkdownToHtml;
     _getCleanHTML;
-    _addJob;
+    _createMediaInliner;
+    _email;
+    _dispatchJob;
+    _fileStager;
     _report;
     _store;
     _urlForPost;
     _newRunId;
     _getTimezone;
     _now;
-    constructor({ readRows, posts, getHtmlToLexical, getMarkdownToHtml, getCleanHTML, addJob, report, store, urlForPost, newRunId, getTimezone, now = () => new Date(), }) {
+    constructor({ readRows, prepareSource = async ({ filePath }) => ({ filePath, cleanup: async () => { } }), posts, getHtmlToLexical, getMarkdownToHtml, getCleanHTML, createMediaInliner, email, dispatchJob, fileStager, report, store, urlForPost, newRunId, getTimezone, now = () => new Date(), }) {
         this._readRows = readRows;
+        this._prepareSource = prepareSource;
         this._posts = posts;
         this._getHtmlToLexical = getHtmlToLexical;
         this._getMarkdownToHtml = getMarkdownToHtml;
         this._getCleanHTML = getCleanHTML;
-        this._addJob = addJob;
+        this._createMediaInliner = createMediaInliner;
+        this._email = email;
+        this._dispatchJob = dispatchJob;
+        this._fileStager = fileStager;
         this._report = report;
         this._store = store;
         this._urlForPost = urlForPost;
@@ -90,9 +100,10 @@ class ContentCSVImporter {
         this._now = now;
     }
     async importCSV(request) {
-        let rows;
+        const emailRecipient = request.requestUserEmail ?? (await this._email.getDefaultRecipient());
+        let stagedFile;
         try {
-            rows = await this._readRows(request.filePath, request.mapping);
+            stagedFile = await this._fileStager.stage(request);
         }
         catch (error) {
             throw new errors.ValidationError({
@@ -100,52 +111,103 @@ class ContentCSVImporter {
                 err: error,
             });
         }
-        // Temporary while import state is held in memory: the durable job
-        // system milestone removes the cap.
-        if (rows.length > MAX_POSTS) {
-            throw new errors.ValidationError({
-                message: tpl(messages.tooManyPosts, { max: MAX_POSTS }),
+        let handedOff = false;
+        try {
+            const stagedRequest = {
+                filePath: stagedFile.path,
+                fileName: stagedFile.name,
+                mapping: request.mapping,
+                requestUserEmail: request.requestUserEmail,
+            };
+            const { source, preparedRows } = await this.readPreparedRows(stagedRequest);
+            await this.cleanupSource(source.cleanup);
+            this.assertWithinPostLimit(preparedRows.rows);
+            const runId = this._newRunId();
+            const importTagNames = buildImportTagNames(runId, this._getTimezone(), this._now());
+            this._store.create(runId, preparedRows.rows.length, preparedRows.columns);
+            const job = new content_csv_import_job_1.default({
+                importId: runId,
+                file: stagedFile,
+                mapping: request.mapping,
+                importTagNames,
+                emailRecipient,
             });
+            logLifecycle('queued');
+            try {
+                await this._dispatchJob(job);
+            }
+            catch (error) {
+                this._store.fail(runId, messageOf(error));
+                this._store.release(runId);
+                throw error;
+            }
+            handedOff = true;
+            return { importId: runId, total: preparedRows.rows.length };
+        }
+        finally {
+            if (!handedOff) {
+                await this.cleanupStagedFile(stagedFile);
+            }
+        }
+    }
+    async handle(job) {
+        let source;
+        try {
+            const prepared = await this.readPreparedRows({
+                filePath: job.file.path,
+                fileName: job.file.name,
+                mapping: job.mapping,
+            });
+            source = prepared.source;
+            this.assertWithinPostLimit(prepared.preparedRows.rows);
+            await this.processRows(job.importId, job.importTagNames, prepared.preparedRows.rows, prepared.source);
+        }
+        catch (error) {
+            this._store.fail(job.importId, messageOf(error));
+            throw error;
+        }
+        finally {
+            if (source) {
+                await this.cleanupSource(source.cleanup);
+            }
+            const run = this._store.get(job.importId);
+            if (run) {
+                await this.settle(() => this._email.send(run, job.emailRecipient));
+            }
+            this._store.release(job.importId);
+            await this.cleanupStagedFile(job.file);
         }
-        const runId = this._newRunId();
-        const importTagNames = buildImportTagNames(runId, this._getTimezone(), this._now());
-        this._store.create(runId, rows.length);
-        logLifecycle('queued');
-        this._addJob({
-            job: () => this.runImportJob(runId, importTagNames, rows),
-            offloaded: false,
-            name: 'content-import',
-        });
-        return { importId: runId, total: rows.length };
-    }
-    // Must resolve in every case: the job manager reads a rejected inline job as a
-    // defect in the job itself, and there is no retry behind it.
-    async runImportJob(runId, importTagNames, rows) {
-        const startedAt = Date.now();
-        logLifecycle('started');
+    }
+    allSettled() {
+        return this._store.allSettled();
+    }
+    async processRows(runId, importTagNames, rows, source) {
         let urlFailureCount = 0;
         let firstUrlFailure;
-        let failed = false;
         try {
+            if (source.assets) {
+                await source.assets.store();
+                source.assets.rewriteRows(rows.map(({ data }) => data));
+            }
             const htmlToLexical = this._getHtmlToLexical();
             const markdownToHtml = this._getMarkdownToHtml();
             const cleanHTML = this._getCleanHTML();
-            let attemptedWrites = 0;
+            const media = this._createMediaInliner();
             let successfulWrites = 0;
-            let failedWrites = 0;
-            let firstWriteFailure;
-            for (const [index, row] of rows.entries()) {
-                const line = index + 2;
+            let failedRows = 0;
+            let firstRowFailure;
+            for (const preparedRow of rows) {
+                const { data: row, source: sourceCells, line } = preparedRow;
                 let data;
                 try {
                     data = (0, post_data_1.default)(row, htmlToLexical, importTagNames, markdownToHtml, cleanHTML);
                 }
                 catch (error) {
                     if (error instanceof post_data_1.RowSkipped) {
-                        this._store.record(runId, {
+                        this.recordOutcome(runId, sourceCells, {
                             line,
                             title: row.title || null,
-                            status: 'skipped',
+                            status: 'failed',
                             reason: messageOf(error),
                         });
                         continue;
@@ -154,8 +216,29 @@ class ContentCSVImporter {
                     // failure. Stop the run before misclassifying it as a lost write.
                     throw error;
                 }
-                attemptedWrites += 1;
+                try {
+                    await media.inline(data);
+                }
+                catch (error) {
+                    if (error instanceof media_1.MediaInliningFailure) {
+                        if (failedRows === 0) {
+                            firstRowFailure = error;
+                        }
+                        failedRows += 1;
+                        this.recordOutcome(runId, sourceCells, {
+                            line,
+                            title: row.title,
+                            status: 'failed',
+                            reason: messageOf(error),
+                            mediaFailures: error.failures,
+                        });
+                        continue;
+                    }
+                    throw error;
+                }
                 let post;
+                let writeStatus;
+                let warnings;
                 try {
                     // options.importing preserves the supplied timestamps and keeps the import silent:
                     // the webhook, Slack, IndexNow and mention consumers all stand down on it, and a
@@ -163,18 +246,37 @@ class ContentCSVImporter {
                     // it, one reason status is never 'scheduled'). Pinned by
                     // test/e2e-webhooks/posts-importer.test.js. A fresh options object per row: the
                     // model layer mutates it.
-                    post = await this._posts.create(data, {
+                    const result = await this._posts.write(data, {
                         importing: true,
                         context: { internal: true },
+                    }, {
+                        sourceUpdatedAt: row.updated_at,
+                        runTagName: importTagNames[1],
+                        authorNames: row.authors,
+                        authorEmails: row.author_emails,
+                        tagNames: row.tags,
                     });
+                    if (result.status === 'skipped') {
+                        this.recordOutcome(runId, sourceCells, {
+                            line,
+                            title: row.title,
+                            status: 'skipped',
+                            reason: result.reason,
+                            duplicate: result.duplicate,
+                        });
+                        continue;
+                    }
+                    post = result.post;
+                    writeStatus = result.status;
+                    warnings = result.warnings;
                     successfulWrites += 1;
                 }
                 catch (error) {
-                    if (failedWrites === 0) {
-                        firstWriteFailure = error;
+                    if (failedRows === 0) {
+                        firstRowFailure = error;
                     }
-                    failedWrites += 1;
-                    this._store.record(runId, {
+                    failedRows += 1;
+                    this.recordOutcome(runId, sourceCells, {
                         line,
                         title: row.title,
                         status: 'failed',
@@ -185,8 +287,10 @@ class ContentCSVImporter {
                 const outcome = {
                     line,
                     title: row.title,
-                    status: 'created',
+                    status: writeStatus,
                     postId: post.id,
+                    postType: data.type,
+                    ...(warnings.length > 0 ? { warnings } : {}),
                 };
                 try {
                     outcome.url = this._urlForPost(post);
@@ -197,31 +301,53 @@ class ContentCSVImporter {
                     }
                     urlFailureCount += 1;
                 }
-                this._store.record(runId, outcome);
+                this.recordOutcome(runId, sourceCells, outcome);
             }
-            if (attemptedWrites > 0 && successfulWrites === 0 && failedWrites === attemptedWrites) {
+            if (failedRows > 0 && successfulWrites === 0) {
                 this._report(new errors.InternalServerError({
                     message: tpl(messages.allWritesFailed, {
-                        count: failedWrites,
-                        postNoun: failedWrites === 1 ? 'post' : 'posts',
+                        count: failedRows,
+                        postNoun: failedRows === 1 ? 'post' : 'posts',
                     }),
-                    err: firstWriteFailure,
+                    err: firstRowFailure,
                 }));
             }
             this.reportUrlFailures(urlFailureCount, firstUrlFailure);
             this._store.finish(runId);
         }
         catch (error) {
-            failed = true;
             this.reportUrlFailures(urlFailureCount, firstUrlFailure);
-            this._report(error);
-            this._store.fail(runId, messageOf(error));
+            throw error;
         }
-        finally {
-            const outcome = failed ? 'failed after' : 'completed in';
-            logLifecycle(`${outcome} ${Date.now() - startedAt}ms`);
+    }
+    async readPreparedRows(request) {
+        const source = await this._prepareSource(request);
+        try {
+            const result = await this._readRows(source.filePath, request.mapping);
+            const preparedRows = Array.isArray(result)
+                ? { columns: [], rows: result.map((data, index) => ({ data, line: index + 2 })) }
+                : result;
+            return { source, preparedRows };
+        }
+        catch (error) {
+            await this.cleanupSource(source.cleanup);
+            throw new errors.ValidationError({
+                message: tpl(messages.unreadableFile),
+                err: error,
+            });
         }
     }
+    assertWithinPostLimit(rows) {
+        // Temporary while import state is held in memory: M8 removes the cap.
+        if (rows.length > MAX_POSTS) {
+            throw new errors.ValidationError({
+                message: tpl(messages.tooManyPosts, { max: MAX_POSTS }),
+            });
+        }
+    }
+    recordOutcome(runId, source, outcome) {
+        this._store.record(runId, source ? { ...outcome, source } : outcome);
+    }
     reportUrlFailures(count, firstFailure) {
         if (count > 0) {
             this._report(new errors.InternalServerError({
@@ -233,6 +359,30 @@ class ContentCSVImporter {
             }));
         }
     }
+    async cleanupSource(cleanup) {
+        try {
+            await cleanup();
+        }
+        catch (error) {
+            this._report(error);
+        }
+    }
+    async cleanupStagedFile(file) {
+        try {
+            await this._fileStager.remove(file);
+        }
+        catch (error) {
+            this._report(error);
+        }
+    }
+    async settle(operation) {
+        try {
+            await operation();
+        }
+        catch (error) {
+            this._report(error);
+        }
+    }
 }
 function messageOf(error) {
     if (error &&

package/core/server/services/content-import/import/local-media-url.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalMediaUrl = isLocalMediaUrl;
+const CONTENT_PATH_PREFIXES = ['/content/images', '/content/media', '/content/files'];
+function normalizedPathPrefix(value) {
+    if (!value.startsWith('/')) {
+        return `/${value}`.replace(/\/+$/, '');
+    }
+    return value.replace(/\/+$/, '');
+}
+function pathHasPrefix(pathname, prefix) {
+    return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function isContentPath(pathname, subdirs) {
+    const normalizedPathname = normalizedPathPrefix(pathname);
+    const prefixes = subdirs.flatMap((subdir) => {
+        const normalizedSubdir = normalizedPathPrefix(subdir);
+        return CONTENT_PATH_PREFIXES.map((prefix) => `${normalizedSubdir}${prefix}`);
+    });
+    return [...CONTENT_PATH_PREFIXES, ...prefixes].some((prefix) => pathHasPrefix(normalizedPathname, prefix));
+}
+function parseUrl(value) {
+    try {
+        return new URL(value.startsWith('//') ? `https:${value}` : value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function matchesBaseUrl(source, baseUrl) {
+    const base = parseUrl(baseUrl.trim());
+    if (!base || source.host !== base.host) {
+        return false;
+    }
+    const basePath = normalizedPathPrefix(base.pathname);
+    return basePath === '' || basePath === '/' || pathHasPrefix(source.pathname, basePath);
+}
+/**
+ * Returns whether a media reference already belongs to this Ghost site or one
+ * of its configured asset hosts. This only classifies URLs; it never checks
+ * whether the referenced file exists.
+ */
+function isLocalMediaUrl(sourceUrl, options) {
+    const value = sourceUrl.trim();
+    if (value.startsWith('__GHOST_URL__')) {
+        return true;
+    }
+    if (value.startsWith('/') && !value.startsWith('//')) {
+        return isContentPath(value, [options.subdir]);
+    }
+    const source = parseUrl(value);
+    if (!source) {
+        return false;
+    }
+    if (options.assetBaseUrls.some((baseUrl) => typeof baseUrl === 'string' && matchesBaseUrl(source, baseUrl))) {
+        return true;
+    }
+    const site = parseUrl(options.siteUrl);
+    if (!site || source.host !== site.host) {
+        return false;
+    }
+    return isContentPath(source.pathname, [options.subdir, site.pathname]);
+}