@tryghost/url-utils 4.4.14 → 4.5.0

package/lib/UrlUtils.js

@@ -23,6 +23,12 @@ module.exports = class UrlUtils {
      * @param {Object} [options.slugs] object with 2 properties reserved and protected containing arrays of special case slugs
      * @param {Number} [options.redirectCacheMaxAge]
      * @param {String} [options.staticImageUrlPrefix='content/images'] static prefix for serving images. Should not be passed in, unless customizing ghost instance image storage
+     * @param {String} [options.staticFilesUrlPrefix='content/files'] static prefix for serving files. Should not be passed in, unless customizing ghost instance file storage
+     * @param {String} [options.staticMediaUrlPrefix='content/media'] static prefix for serving media. Should not be passed in, unless customizing ghost instance media storage
+     * @param {object} [options.assetBaseUrls] asset CDN base URLs
+     * @param {string} [options.assetBaseUrls.image] image asset CDN base URL
+     * @param {string} [options.assetBaseUrls.files] files asset CDN base URL
+     * @param {string} [options.assetBaseUrls.media] media asset CDN base URL
      */
     constructor(options = {}) {
         const defaultOptions = {
@@ -30,16 +36,40 @@ module.exports = class UrlUtils {
             redirectCacheMaxAge: null,
             baseApiPath: '/ghost/api',
             defaultApiType: 'content',
-            staticImageUrlPrefix: 'content/images'
+            staticImageUrlPrefix: 'content/images',
+            staticFilesUrlPrefix: 'content/files',
+            staticMediaUrlPrefix: 'content/media'
         };
 
         this._config = assignOptions({}, defaultOptions, options);
 
+        const assetBaseUrls = options.assetBaseUrls || {};
+        this._assetBaseUrls = {
+            image: assetBaseUrls.image || null,
+            files: assetBaseUrls.files || null,
+            media: assetBaseUrls.media || null
+        };
+
         this.getSubdir = options.getSubdir;
         this.getSiteUrl = options.getSiteUrl;
         this.getAdminUrl = options.getAdminUrl;
     }
 
+    _assetOptionDefaults() {
+        return {
+            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
+            staticFilesUrlPrefix: this._config.staticFilesUrlPrefix,
+            staticMediaUrlPrefix: this._config.staticMediaUrlPrefix,
+            imageBaseUrl: this._assetBaseUrls.image || null,
+            filesBaseUrl: this._assetBaseUrls.files || null,
+            mediaBaseUrl: this._assetBaseUrls.media || null
+        };
+    }
+
+    _buildAssetOptions(additionalDefaults = {}, options) {
+        return assignOptions({}, this._assetOptionDefaults(), additionalDefaults, options || {});
+    }
+
     getProtectedSlugs() {
         let subDir = this.getSubdir();
 
@@ -234,23 +264,28 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        return utils.toTransformReady(url, this.getSiteUrl(), itemPath, options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.toTransformReady(url, this.getSiteUrl(), itemPath, _options);
     }
 
     absoluteToTransformReady(url, options) {
-        return utils.absoluteToTransformReady(url, this.getSiteUrl(), options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.absoluteToTransformReady(url, this.getSiteUrl(), _options);
     }
 
     relativeToTransformReady(url, options) {
-        return utils.relativeToTransformReady(url, this.getSiteUrl(), options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.relativeToTransformReady(url, this.getSiteUrl(), _options);
     }
 
     transformReadyToAbsolute(url, options) {
-        return utils.transformReadyToAbsolute(url, this.getSiteUrl(), options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.transformReadyToAbsolute(url, this.getSiteUrl(), _options);
     }
 
     transformReadyToRelative(url, options) {
-        return utils.transformReadyToRelative(url, this.getSiteUrl(), options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.transformReadyToRelative(url, this.getSiteUrl(), _options);
     }
 
     htmlToTransformReady(html, itemPath, options) {
@@ -258,7 +293,8 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        return utils.htmlToTransformReady(html, this.getSiteUrl(), itemPath, options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.htmlToTransformReady(html, this.getSiteUrl(), itemPath, _options);
     }
 
     /**
@@ -276,11 +312,9 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.htmlRelativeToAbsolute(html, this.getSiteUrl(), itemPath, _options);
     }
 
@@ -289,29 +323,23 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.htmlRelativeToTransformReady(html, this.getSiteUrl(), itemPath, _options);
     }
 
     htmlAbsoluteToRelative(html, options = {}) {
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.htmlAbsoluteToRelative(html, this.getSiteUrl(), _options);
     }
 
     htmlAbsoluteToTransformReady(html, options = {}) {
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.htmlAbsoluteToTransformReady(html, this.getSiteUrl(), _options);
     }
 
@@ -320,7 +348,8 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        return utils.markdownToTransformReady(markdown, this.getSiteUrl(), itemPath, options);
+        const _options = this._buildAssetOptions({}, options);
+        return utils.markdownToTransformReady(markdown, this.getSiteUrl(), itemPath, _options);
     }
 
     markdownRelativeToAbsolute(markdown, itemPath, options) {
@@ -328,11 +357,9 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.markdownRelativeToAbsolute(markdown, this.getSiteUrl(), itemPath, _options);
     }
 
@@ -341,29 +368,23 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.markdownRelativeToTransformReady(markdown, this.getSiteUrl(), itemPath, _options);
     }
 
     markdownAbsoluteToRelative(markdown, options = {}) {
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.markdownAbsoluteToRelative(markdown, this.getSiteUrl(), _options);
     }
 
     markdownAbsoluteToTransformReady(markdown, options) {
-        const defaultOptions = {
-            assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        const _options = this._buildAssetOptions({
+            assetsOnly: false
+        }, options);
         return utils.markdownAbsoluteToTransformReady(markdown, this.getSiteUrl(), _options);
     }
 
@@ -372,10 +393,9 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        }, options);
         return utils.mobiledocToTransformReady(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
     }
 
@@ -384,12 +404,10 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        }, options);
         return utils.mobiledocRelativeToAbsolute(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
     }
 
@@ -398,32 +416,26 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        }, options);
         return utils.mobiledocRelativeToTransformReady(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
     }
 
     mobiledocAbsoluteToRelative(serializedMobiledoc, options = {}) {
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        }, options);
         return utils.mobiledocAbsoluteToRelative(serializedMobiledoc, this.getSiteUrl(), _options);
     }
 
     mobiledocAbsoluteToTransformReady(serializedMobiledoc, options = {}) {
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        }, options);
         return utils.mobiledocAbsoluteToTransformReady(serializedMobiledoc, this.getSiteUrl(), _options);
     }
 
@@ -432,10 +444,9 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        }, options);
         return utils.lexicalToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
     }
 
@@ -444,12 +455,10 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        }, options);
         return utils.lexicalRelativeToAbsolute(serializedLexical, this.getSiteUrl(), itemPath, _options);
     }
 
@@ -458,40 +467,31 @@ module.exports = class UrlUtils {
             options = itemPath;
             itemPath = null;
         }
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options || {});
+        }, options);
         return utils.lexicalRelativeToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
     }
 
     lexicalAbsoluteToRelative(serializedLexical, options = {}) {
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        }, options);
         return utils.lexicalAbsoluteToRelative(serializedLexical, this.getSiteUrl(), _options);
     }
 
     lexicalAbsoluteToTransformReady(serializedLexical, options = {}) {
-        const defaultOptions = {
+        const _options = this._buildAssetOptions({
             assetsOnly: false,
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix,
             cardTransformers: this._config.cardTransformers
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        }, options);
         return utils.lexicalAbsoluteToTransformReady(serializedLexical, this.getSiteUrl(), _options);
     }
 
     plaintextToTransformReady(plaintext, options = {}) {
-        const defaultOptions = {
-            staticImageUrlPrefix: this._config.staticImageUrlPrefix
-        };
-        const _options = assignOptions({}, defaultOptions, options);
+        const _options = this._buildAssetOptions({}, options);
         return utils.plaintextToTransformReady(plaintext, this.getSiteUrl(), _options);
     }
 
@@ -537,6 +537,14 @@ module.exports = class UrlUtils {
         return this._config.staticImageUrlPrefix;
     }
 
+    get STATIC_FILES_URL_PREFIX() {
+        return this._config.staticFilesUrlPrefix;
+    }
+
+    get STATIC_MEDIA_URL_PREFIX() {
+        return this._config.staticMediaUrlPrefix;
+    }
+
     // expose underlying functions to ease testing
     get _utils() {
         return utils;

package/lib/utils/absolute-to-transform-ready.js

@@ -1,39 +1,68 @@
+const {URL} = require('url');
 const absoluteToRelative = require('./absolute-to-relative');
 
-const absoluteToTransformReady = function (url, root, _options) {
+function isRelative(url) {
+    let parsedInput;
+    try {
+        parsedInput = new URL(url, 'http://relative');
+    } catch (e) {
+        // url was unparseable
+        return false;
+    }
+
+    return parsedInput.origin === 'http://relative';
+}
+
+const absoluteToTransformReady = function (url, root, _options = {}) {
     const defaultOptions = {
         replacementStr: '__GHOST_URL__',
-        withoutSubdirectory: true
+        withoutSubdirectory: true,
+        staticImageUrlPrefix: 'content/images',
+        staticFilesUrlPrefix: 'content/files',
+        staticMediaUrlPrefix: 'content/media',
+        imageBaseUrl: null,
+        filesBaseUrl: null,
+        mediaBaseUrl: null
     };
     const options = Object.assign({}, defaultOptions, _options);
 
-    // return relative urls as-is
-    try {
-        const parsedURL = new URL(url, 'http://relative');
-        if (parsedURL.origin === 'http://relative') {
-            return url;
-        }
-    } catch (e) {
-        // url was unparseable
+    if (isRelative(url)) {
         return url;
     }
 
     // convert to relative with stripped subdir
     // always returns root-relative starting with forward slash
-    const relativeUrl = absoluteToRelative(url, root, options);
+    const rootRelativeUrl = absoluteToRelative(url, root, options);
 
-    // return still absolute urls as-is (eg. external site, mailto, etc)
-    try {
-        const parsedURL = new URL(relativeUrl, 'http://relative');
-        if (parsedURL.origin !== 'http://relative') {
-            return url;
+    if (isRelative(rootRelativeUrl)) {
+        return `${options.replacementStr}${rootRelativeUrl}`;
+    }
+
+    if (options.mediaBaseUrl) {
+        const mediaRelativeUrl = absoluteToRelative(url, options.mediaBaseUrl, options);
+
+        if (isRelative(mediaRelativeUrl)) {
+            return `${options.replacementStr}${mediaRelativeUrl}`;
+        }
+    }
+
+    if (options.filesBaseUrl) {
+        const filesRelativeUrl = absoluteToRelative(url, options.filesBaseUrl, options);
+
+        if (isRelative(filesRelativeUrl)) {
+            return `${options.replacementStr}${filesRelativeUrl}`;
+        }
+    }
+
+    if (options.imageBaseUrl) {
+        const imageRelativeUrl = absoluteToRelative(url, options.imageBaseUrl, options);
+
+        if (isRelative(imageRelativeUrl)) {
+            return `${options.replacementStr}${imageRelativeUrl}`;
         }
-    } catch (e) {
-        // url was unparseable
-        return url;
     }
 
-    return `${options.replacementStr}${relativeUrl}`;
+    return url;
 };
 
 module.exports = absoluteToTransformReady;

package/lib/utils/build-early-exit-match.js

@@ -0,0 +1,42 @@
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Build a regex pattern that matches any of the configured base URLs (site URL + CDN URLs).
+ * This is used for early exit optimizations - if content doesn't contain any of these URLs,
+ * we can skip expensive parsing.
+ *
+ * @param {string} siteUrl - The site's base URL
+ * @param {Object} options - Options containing CDN base URLs
+ * @param {string} [options.imageBaseUrl] - CDN base URL for images
+ * @param {string} [options.filesBaseUrl] - CDN base URL for files
+ * @param {string} [options.mediaBaseUrl] - CDN base URL for media
+ * @param {boolean} [options.ignoreProtocol=true] - Whether to strip protocol from URLs
+ * @returns {string|null} Regex pattern matching any configured base URL, or null if none configured
+ */
+function buildEarlyExitMatch(siteUrl, options = {}) {
+    const candidates = [siteUrl, options.imageBaseUrl, options.filesBaseUrl, options.mediaBaseUrl]
+        .filter(Boolean)
+        .map((value) => {
+            let normalized = options.ignoreProtocol ? value.replace(/http:|https:/, '') : value;
+            return normalized.replace(/\/$/, '');
+        })
+        .filter(Boolean)
+        .map(escapeRegExp);
+
+    if (!candidates.length) {
+        return null;
+    }
+
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+
+    return `(?:${candidates.join('|')})`;
+}
+
+module.exports = {
+    buildEarlyExitMatch,
+    escapeRegExp
+};

package/lib/utils/deduplicate-double-slashes.js

@@ -1,5 +1,8 @@
 function deduplicateDoubleSlashes(url) {
-    return url.replace(/\/\//g, '/');
+    // Preserve protocol slashes (e.g., http://, https://) and only deduplicate
+    // slashes in the path portion. The pattern (^|[^:])\/\/+ matches double slashes
+    // that are either at the start of the string or not preceded by a colon.
+    return url.replace(/(^|[^:])\/\/+/g, '$1/');
 }
 
 module.exports = deduplicateDoubleSlashes;

package/lib/utils/html-absolute-to-transform-ready.js

@@ -1,13 +1,13 @@
 const htmlTransform = require('./html-transform');
 const absoluteToTransformReady = require('./absolute-to-transform-ready');
+const {buildEarlyExitMatch} = require('./build-early-exit-match');
 
 const htmlAbsoluteToTransformReady = function (html = '', siteUrl, _options) {
     const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
     const options = Object.assign({}, defaultOptions, _options || {});
 
-    // exit early and avoid parsing if the content does not contain the siteUrl
-    options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
-    options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
+    // exit early and avoid parsing if the content does not contain the siteUrl or configured asset bases
+    options.earlyExitMatchStr = buildEarlyExitMatch(siteUrl, options);
 
     // need to ignore itemPath because absoluteToRelative doesn't take that option
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {

package/lib/utils/markdown-absolute-to-transform-ready.js

@@ -1,13 +1,13 @@
 const markdownTransform = require('./markdown-transform');
 const absoluteToTransformReady = require('./absolute-to-transform-ready');
 const htmlAbsoluteToTransformReady = require('./html-absolute-to-transform-ready');
+const {buildEarlyExitMatch} = require('./build-early-exit-match');
 
 function markdownAbsoluteToTransformReady(markdown = '', siteUrl, _options = {}) {
     const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
     const options = Object.assign({}, defaultOptions, _options);
 
-    options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
-    options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
+    options.earlyExitMatchStr = buildEarlyExitMatch(siteUrl, options);
 
     // need to ignore itemPath because absoluteToTransformReady functions doen't take that option
     const transformFunctions = {

package/lib/utils/plaintext-absolute-to-transform-ready.js

@@ -1,7 +1,23 @@
 const absoluteToTransformReady = require('./absolute-to-transform-ready');
+const {escapeRegExp} = require('./build-early-exit-match');
 
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function buildLinkRegex(rootUrl, options = {}) {
+    // Build a regex that matches links from ANY configured base URL (site + CDNs)
+    const baseUrls = [rootUrl, options.imageBaseUrl, options.filesBaseUrl, options.mediaBaseUrl]
+        .filter(Boolean);
+
+    const patterns = baseUrls.map((baseUrl) => {
+        const parsed = new URL(baseUrl);
+        const escapedUrl = escapeRegExp(`${parsed.hostname}${parsed.pathname.replace(/\/$/, '')}`);
+        return escapedUrl;
+    });
+
+    if (!patterns.length) {
+        return null;
+    }
+
+    const pattern = patterns.length === 1 ? patterns[0] : `(?:${patterns.join('|')})`;
+    return new RegExp(` \\[(https?://${pattern}.*?)\\]`, 'g');
 }
 
 const plaintextAbsoluteToTransformReady = function plaintextAbsoluteToTransformReady(plaintext, rootUrl, itemPath, options) {
@@ -13,9 +29,7 @@ const plaintextAbsoluteToTransformReady = function plaintextAbsoluteToTransformR
 
     // plaintext links look like "Link title [url]"
     // those links are all we care about so we can do a fast regex here
-    const rootURL = new URL(rootUrl);
-    const escapedRootUrl = escapeRegExp(`${rootURL.hostname}${rootURL.pathname.replace(/\/$/, '')}`);
-    const linkRegex = new RegExp(` \\[(https?://${escapedRootUrl}.*?)\\]`, 'g');
+    const linkRegex = buildLinkRegex(rootUrl, options);
 
     return plaintext.replace(linkRegex, function (fullMatch, url) {
         const newUrl = absoluteToTransformReady(`${url}`, rootUrl, options);

package/lib/utils/transform-ready-to-absolute.js

@@ -4,7 +4,13 @@ function escapeRegExp(string) {
 
 const transformReadyToAbsolute = function (str = '', root, _options = {}) {
     const defaultOptions = {
-        replacementStr: '__GHOST_URL__'
+        replacementStr: '__GHOST_URL__',
+        staticImageUrlPrefix: 'content/images',
+        staticFilesUrlPrefix: 'content/files',
+        staticMediaUrlPrefix: 'content/media',
+        imageBaseUrl: null,
+        filesBaseUrl: null,
+        mediaBaseUrl: null
     };
     const options = Object.assign({}, defaultOptions, _options);
 
@@ -14,7 +20,23 @@ const transformReadyToAbsolute = function (str = '', root, _options = {}) {
 
     const replacementRegex = new RegExp(escapeRegExp(options.replacementStr), 'g');
 
-    return str.replace(replacementRegex, root.replace(/\/$/, ''));
+    return str.replace(replacementRegex, (match, offset) => {
+        const remainder = str.slice(offset + match.length);
+
+        if (remainder.startsWith(`/${options.staticMediaUrlPrefix}`) && options.mediaBaseUrl) {
+            return options.mediaBaseUrl.replace(/\/$/, '');
+        }
+
+        if (remainder.startsWith(`/${options.staticFilesUrlPrefix}`) && options.filesBaseUrl) {
+            return options.filesBaseUrl.replace(/\/$/, '');
+        }
+
+        if (remainder.startsWith(`/${options.staticImageUrlPrefix}`) && options.imageBaseUrl) {
+            return options.imageBaseUrl.replace(/\/$/, '');
+        }
+
+        return root.replace(/\/$/, '');
+    });
 };
 
 module.exports = transformReadyToAbsolute;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/url-utils",
-  "version": "4.4.14",
+  "version": "4.5.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TryGhost/SDK.git",
@@ -23,10 +23,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@tryghost/config-url-helpers": "^1.0.17",
+    "@tryghost/config-url-helpers": "^1.0.18",
     "c8": "10.1.3",
-    "mocha": "11.2.2",
-    "rewire": "8.0.0",
+    "mocha": "11.7.5",
+    "rewire": "9.0.1",
     "should": "13.2.3",
     "sinon": "21.0.0"
   },
@@ -38,6 +38,5 @@
     "remark": "^11.0.2",
     "remark-footnotes": "^1.0.0",
     "unist-util-visit": "^2.0.0"
-  },
-  "gitHead": "b10773947244536b8829fec0540819990c901987"
+  }
 }