@tryghost/url-utils 5.0.0-rc.1 → 5.1.0

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import UrlUtils from './UrlUtils';
+export = UrlUtils;

package/lib/index.js

@@ -0,0 +1,6 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const UrlUtils_1 = __importDefault(require("./UrlUtils"));
+module.exports = UrlUtils_1.default;

package/lib/utils/absolute-to-relative.d.ts

@@ -0,0 +1,19 @@
+export interface AbsoluteToRelativeOptions {
+    ignoreProtocol: boolean;
+    withoutSubdirectory: boolean;
+    assetsOnly: boolean;
+    staticImageUrlPrefix: string;
+}
+export type AbsoluteToRelativeOptionsInput = Partial<AbsoluteToRelativeOptions>;
+/**
+ * Convert an absolute URL to a root-relative path if it matches the supplied root domain.
+ *
+ * @param {string} url Absolute URL to convert to relative if possible
+ * @param {string} rootUrl Absolute URL to which the returned relative URL will match the domain root
+ * @param {Object} [options] Options that affect the conversion
+ * @param {boolean} [options.ignoreProtocol=true] Ignore protocol when matching url to root
+ * @param {boolean} [options.withoutSubdirectory=false] Strip the root subdirectory from the returned path
+ * @returns {string} The passed-in url or a relative path
+ */
+declare const absoluteToRelative: (url: string, rootUrl?: string, _options?: AbsoluteToRelativeOptionsInput) => string;
+export default absoluteToRelative;

package/lib/utils/absolute-to-relative.js

@@ -1,7 +1,10 @@
-// require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
-const stripSubdirectoryFromPath = require('./strip-subdirectory-from-path');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+const strip_subdirectory_from_path_1 = __importDefault(require("./strip-subdirectory-from-path"));
 /**
  * Convert an absolute URL to a root-relative path if it matches the supplied root domain.
  *
@@ -20,44 +23,38 @@ const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options =
         staticImageUrlPrefix: 'content/images'
     };
     const options = Object.assign({}, defaultOptions, _options);
-
     if (options.assetsOnly) {
         const staticImageUrlPrefixRegex = new RegExp(options.staticImageUrlPrefix);
         if (!url.match(staticImageUrlPrefixRegex)) {
             return url;
         }
     }
-
     let parsedUrl;
     let parsedRoot;
-
     try {
-        parsedUrl = new URL(url, 'http://relative');
-        parsedRoot = parsedUrl.origin === 'null' ? undefined : new URL(rootUrl || parsedUrl.origin);
-
+        parsedUrl = new url_1.URL(url, 'http://relative');
+        parsedRoot = parsedUrl.origin === 'null' ? undefined : new url_1.URL(rootUrl || parsedUrl.origin);
         // return the url as-is if it was relative or non-http
         if (parsedUrl.origin === 'null' || parsedUrl.origin === 'http://relative') {
             return url;
         }
-    } catch (e) {
+    }
+    catch (e) {
+        return url;
+    }
+    if (!parsedRoot) {
         return url;
     }
-
     const matchesHost = parsedUrl.host === parsedRoot.host;
     const matchesProtocol = parsedUrl.protocol === parsedRoot.protocol;
     const matchesPath = parsedUrl.pathname.indexOf(parsedRoot.pathname) === 0;
-
     if (matchesHost && (options.ignoreProtocol || matchesProtocol) && matchesPath) {
         let path = parsedUrl.href.replace(parsedUrl.origin, '');
-
         if (options.withoutSubdirectory) {
-            path = stripSubdirectoryFromPath(path, rootUrl);
+            path = (0, strip_subdirectory_from_path_1.default)(path, rootUrl);
         }
-
         return path;
     }
-
     return url;
 };
-
-module.exports = absoluteToRelative;
+exports.default = absoluteToRelative;

package/lib/utils/absolute-to-transform-ready.d.ts

@@ -0,0 +1,13 @@
+import type { TransformReadyReplacementOptions } from './types';
+import { type AbsoluteToRelativeOptions } from './absolute-to-relative';
+export interface AbsoluteToTransformReadyOptions extends TransformReadyReplacementOptions, AbsoluteToRelativeOptions {
+    withoutSubdirectory: boolean;
+    staticFilesUrlPrefix?: string;
+    staticMediaUrlPrefix?: string;
+    imageBaseUrl?: string | null;
+    filesBaseUrl?: string | null;
+    mediaBaseUrl?: string | null;
+}
+export type AbsoluteToTransformReadyOptionsInput = Partial<AbsoluteToTransformReadyOptions>;
+declare const absoluteToTransformReady: (url: string, root: string, _options?: AbsoluteToTransformReadyOptionsInput) => string;
+export default absoluteToTransformReady;

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

@@ -1,69 +1,21 @@
-const {URL} = require('url');
-const absoluteToRelative = require('./absolute-to-relative');
-
-function normalizeBaseUrl(baseUrl) {
-    if (!baseUrl) {
-        return null;
-    }
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const absolute_to_relative_1 = __importDefault(require("./absolute-to-relative"));
+const url_1 = require("url");
+function isRelative(url) {
+    let parsedInput;
     try {
-        const parsed = new URL(baseUrl);
-        let pathname = parsed.pathname.replace(/\/$/, '');
-        if (pathname === '/') {
-            pathname = '';
-        }
-
-        return {
-            origin: parsed.origin,
-            pathname
-        };
-    } catch (e) {
-        return null;
+        parsedInput = new url_1.URL(url, 'http://relative');
     }
-}
-
-function matchCdnBase(parsedUrl, options) {
-    const candidates = [
-        {base: normalizeBaseUrl(options.mediaBaseUrl), prefix: options.staticMediaUrlPrefix},
-        {base: normalizeBaseUrl(options.filesBaseUrl), prefix: options.staticFilesUrlPrefix}
-    ];
-
-    for (const candidate of candidates) {
-        if (!candidate.base || !candidate.prefix) {
-            continue;
-        }
-
-        if (parsedUrl.origin !== candidate.base.origin) {
-            continue;
-        }
-
-        let pathname = parsedUrl.pathname;
-        const basePath = candidate.base.pathname;
-
-        if (basePath) {
-            if (pathname === basePath) {
-                pathname = '/';
-            } else if (pathname.startsWith(basePath + '/')) {
-                pathname = pathname.slice(basePath.length);
-            } else {
-                continue;
-            }
-        }
-
-        if (!pathname.startsWith('/')) {
-            pathname = `/${pathname}`;
-        }
-
-        if (!pathname.startsWith(`/${candidate.prefix}`)) {
-            continue;
-        }
-
-        return `${pathname}${parsedUrl.search}${parsedUrl.hash}`;
+    catch (e) {
+        // url was unparseable
+        return false;
     }
-
-    return null;
+    return parsedInput.origin === 'http://relative';
 }
-
 const absoluteToTransformReady = function (url, root, _options = {}) {
     const defaultOptions = {
         replacementStr: '__GHOST_URL__',
@@ -73,45 +25,38 @@ const absoluteToTransformReady = function (url, root, _options = {}) {
         staticMediaUrlPrefix: 'content/media',
         imageBaseUrl: null,
         filesBaseUrl: null,
-        mediaBaseUrl: null
+        mediaBaseUrl: null,
+        ignoreProtocol: true,
+        assetsOnly: false
     };
     const options = Object.assign({}, defaultOptions, _options);
-
-    let parsedInput;
-    try {
-        parsedInput = new URL(url, 'http://relative');
-    } catch (e) {
-        // url was unparseable
+    if (isRelative(url)) {
         return url;
     }
-
-    if (parsedInput.origin !== 'http://relative') {
-        const cdnMatch = matchCdnBase(parsedInput, options);
-        if (cdnMatch) {
-            return `${options.replacementStr}${cdnMatch}`;
+    // convert to relative with stripped subdir
+    // always returns root-relative starting with forward slash
+    const rootRelativeUrl = (0, absolute_to_relative_1.default)(url, root, options);
+    if (isRelative(rootRelativeUrl)) {
+        return `${options.replacementStr}${rootRelativeUrl}`;
+    }
+    if (options.mediaBaseUrl) {
+        const mediaRelativeUrl = (0, absolute_to_relative_1.default)(url, options.mediaBaseUrl, options);
+        if (isRelative(mediaRelativeUrl)) {
+            return `${options.replacementStr}${mediaRelativeUrl}`;
         }
     }
-
-    if (parsedInput.origin === 'http://relative') {
-        return url;
+    if (options.filesBaseUrl) {
+        const filesRelativeUrl = (0, absolute_to_relative_1.default)(url, options.filesBaseUrl, options);
+        if (isRelative(filesRelativeUrl)) {
+            return `${options.replacementStr}${filesRelativeUrl}`;
+        }
     }
-
-    // convert to relative with stripped subdir
-    // always returns root-relative starting with forward slash
-    const relativeUrl = 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 (options.imageBaseUrl) {
+        const imageRelativeUrl = (0, absolute_to_relative_1.default)(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;
+exports.default = absoluteToTransformReady;

package/lib/utils/build-early-exit-match.d.ts

@@ -0,0 +1,24 @@
+import type { BaseUrlOptionsInput } from './types';
+declare function escapeRegExp(string: string): string;
+type BuildEarlyExitMatchOptions = BaseUrlOptionsInput & {
+    ignoreProtocol?: boolean;
+};
+/**
+ * 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
+ */
+declare function buildEarlyExitMatch(siteUrl: string, options?: BuildEarlyExitMatchOptions): string | null;
+declare const _default: {
+    buildEarlyExitMatch: typeof buildEarlyExitMatch;
+    escapeRegExp: typeof escapeRegExp;
+};
+export default _default;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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((value) => typeof value === 'string' && value.length > 0)
+        .map((value) => {
+        let normalized = options.ignoreProtocol ? value.replace(/http:|https:/, '') : value;
+        return normalized.replace(/\/$/, '');
+    })
+        .filter((value) => Boolean(value))
+        .map(escapeRegExp);
+    if (!candidates.length) {
+        return null;
+    }
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    return `(?:${candidates.join('|')})`;
+}
+exports.default = {
+    buildEarlyExitMatch,
+    escapeRegExp
+};

package/lib/utils/deduplicate-double-slashes.d.ts

@@ -0,0 +1,2 @@
+declare function deduplicateDoubleSlashes(url: string): string;
+export default deduplicateDoubleSlashes;

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

@@ -1,5 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 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;
+exports.default = deduplicateDoubleSlashes;

package/lib/utils/deduplicate-subdirectory.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Remove duplicated directories from the start of a path or url's path
+ *
+ * @param {string} url URL or pathname with possible duplicate subdirectory
+ * @param {string} rootUrl Root URL with an optional subdirectory
+ * @returns {string} URL or pathname with any duplicated subdirectory removed
+ */
+declare const deduplicateSubdirectory: (url: string, rootUrl: string) => string;
+export default deduplicateSubdirectory;

package/lib/utils/deduplicate-subdirectory.js

@@ -1,5 +1,6 @@
-const {URL} = require('url');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 /**
  * Remove duplicated directories from the start of a path or url's path
  *
@@ -12,20 +13,15 @@ const deduplicateSubdirectory = function deduplicateSubdirectory(url, rootUrl) {
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-
-    const parsedRoot = new URL(rootUrl);
-
+    const parsedRoot = new url_1.URL(rootUrl);
     // do nothing if rootUrl does not have a subdirectory
     if (parsedRoot.pathname === '/') {
         return url;
     }
-
     const subdir = parsedRoot.pathname.replace(/(^\/|\/$)+/g, '');
     // we can have subdirs that match TLDs so we need to restrict matches to
     // duplicates that start with a / or the beginning of the url
     const subdirRegex = new RegExp(`(^|/)${subdir}/${subdir}(/|$)`);
-
     return url.replace(subdirRegex, `$1${subdir}/`);
 };
-
-module.exports = deduplicateSubdirectory;
+exports.default = deduplicateSubdirectory;

package/lib/utils/html-absolute-to-relative.d.ts

@@ -0,0 +1,3 @@
+import type { AbsoluteToRelativeOptionsInput } from './absolute-to-relative';
+declare function htmlAbsoluteToRelative(html: string | undefined, siteUrl: string, _options?: AbsoluteToRelativeOptionsInput): string;
+export default htmlAbsoluteToRelative;

package/lib/utils/html-absolute-to-relative.js

@@ -1,20 +1,20 @@
-const htmlTransform = require('./html-transform');
-const absoluteToRelative = require('./absolute-to-relative');
-
-function htmlAbsoluteToRelative(html = '', siteUrl, _options) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_transform_1 = __importDefault(require("./html-transform"));
+const absolute_to_relative_1 = __importDefault(require("./absolute-to-relative"));
+function htmlAbsoluteToRelative(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(/\/$/, '');
-
     // need to ignore itemPath because absoluteToRelative doesn't take that option
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
-        return absoluteToRelative(_url, _siteUrl, __options);
+        return (0, absolute_to_relative_1.default)(_url, _siteUrl, __options);
     };
-
-    return htmlTransform(html, siteUrl, transformFunction, '', options);
+    return (0, html_transform_1.default)(html, siteUrl, transformFunction, '', options);
 }
-
-module.exports = htmlAbsoluteToRelative;
+exports.default = htmlAbsoluteToRelative;

package/lib/utils/html-absolute-to-transform-ready.d.ts

@@ -0,0 +1,3 @@
+import type { AbsoluteToTransformReadyOptionsInput } from './types';
+declare const htmlAbsoluteToTransformReady: (html: string | undefined, siteUrl: string, _options?: AbsoluteToTransformReadyOptionsInput) => string;
+export default htmlAbsoluteToTransformReady;

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

@@ -1,44 +1,24 @@
-const htmlTransform = require('./html-transform');
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-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('|')})`;
-}
-
-const htmlAbsoluteToTransformReady = function (html = '', siteUrl, _options) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_transform_1 = __importDefault(require("./html-transform"));
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
+const build_early_exit_match_1 = __importDefault(require("./build-early-exit-match"));
+const { buildEarlyExitMatch } = build_early_exit_match_1.default;
+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 or configured asset bases
-    options.earlyExitMatchStr = buildEarlyExitMatch(siteUrl, options);
-
+    const earlyExitMatch = buildEarlyExitMatch(siteUrl, options);
+    if (earlyExitMatch) {
+        options.earlyExitMatchStr = earlyExitMatch;
+    }
     // need to ignore itemPath because absoluteToRelative doesn't take that option
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
-        return absoluteToTransformReady(_url, _siteUrl, __options);
+        return (0, absolute_to_transform_ready_1.default)(_url, _siteUrl, __options);
     };
-
-    return htmlTransform(html, siteUrl, transformFunction, '', options);
+    return (0, html_transform_1.default)(html, siteUrl, transformFunction, '', options);
 };
-
-module.exports = htmlAbsoluteToTransformReady;
+exports.default = htmlAbsoluteToTransformReady;

package/lib/utils/html-relative-to-absolute.d.ts

@@ -0,0 +1,3 @@
+import type { SecureOptionsInput } from './types';
+declare function htmlRelativeToAbsolute(html: string | undefined, siteUrl: string, itemPath: string | null, _options?: SecureOptionsInput): string;
+export default htmlRelativeToAbsolute;

package/lib/utils/html-relative-to-absolute.js

@@ -1,17 +1,18 @@
-const htmlTransform = require('./html-transform');
-const relativeToAbsolute = require('./relative-to-absolute');
-
-function htmlRelativeToAbsolute(html = '', siteUrl, itemPath, _options) {
-    const defaultOptions = {assetsOnly: false, secure: false};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_transform_1 = __importDefault(require("./html-transform"));
+const relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+function htmlRelativeToAbsolute(html = '', siteUrl, itemPath, _options = {}) {
+    const defaultOptions = { assetsOnly: false, secure: false };
     const options = Object.assign({}, defaultOptions, _options || {});
-
     // exit early and avoid parsing if the content does not contain an attribute we might transform
     options.earlyExitMatchStr = 'href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
-    return htmlTransform(html, siteUrl, relativeToAbsolute, itemPath, options);
+    return (0, html_transform_1.default)(html, siteUrl, relative_to_absolute_1.default, itemPath, options);
 }
-
-module.exports = htmlRelativeToAbsolute;
+exports.default = htmlRelativeToAbsolute;

package/lib/utils/html-relative-to-transform-ready.d.ts

@@ -0,0 +1,3 @@
+import { type RelativeToTransformReadyOptionsInput as RelativeToTransformReadyOptionsInputType } from './relative-to-transform-ready';
+declare const htmlRelativeToTransformReady: (html: string | undefined, root: string, itemPath: string | null | RelativeToTransformReadyOptionsInputType, _options?: RelativeToTransformReadyOptionsInputType) => string;
+export default htmlRelativeToTransformReady;

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

@@ -1,28 +1,33 @@
-const htmlTransform = require('./html-transform');
-const relativeToTransformReady = require('./relative-to-transform-ready');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_transform_1 = __importDefault(require("./html-transform"));
+const relative_to_transform_ready_1 = __importDefault(require("./relative-to-transform-ready"));
 const htmlRelativeToTransformReady = function (html = '', root, itemPath, _options) {
     // itemPath is optional, if it's an object may be the options param instead
-    if (typeof itemPath === 'object' && !_options) {
-        _options = itemPath;
-        itemPath = null;
+    let finalItemPath = null;
+    let finalOptions = _options || {};
+    if (typeof itemPath === 'object' && itemPath !== null && !_options) {
+        finalOptions = itemPath;
+        finalItemPath = null;
+    }
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
     }
-
     const defaultOptions = {
         replacementStr: '__GHOST_URL__'
     };
     const overrideOptions = {
         secure: false
     };
-    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
+    const options = Object.assign({}, defaultOptions, finalOptions, overrideOptions);
     // exit early and avoid parsing if the content does not contain an attribute we might transform
     options.earlyExitMatchStr = 'href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
-    return htmlTransform(html, root, relativeToTransformReady, itemPath, options);
+    return (0, html_transform_1.default)(html, root, relative_to_transform_ready_1.default, finalItemPath, options);
 };
-
-module.exports = htmlRelativeToTransformReady;
+exports.default = htmlRelativeToTransformReady;

package/lib/utils/html-to-transform-ready.d.ts

@@ -0,0 +1,3 @@
+import type { HtmlTransformOptionsInput } from './types';
+declare function htmlToTransformReady(html: string, siteUrl: string, itemPath: string | null | HtmlTransformOptionsInput, options?: HtmlTransformOptionsInput): string;
+export default htmlToTransformReady;

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

@@ -1,13 +1,21 @@
-const htmlRelativeToAbsolute = require('./html-relative-to-absolute');
-const htmlAbsoluteToTransformReady = require('./html-absolute-to-transform-ready');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const html_relative_to_absolute_1 = __importDefault(require("./html-relative-to-absolute"));
+const html_absolute_to_transform_ready_1 = __importDefault(require("./html-absolute-to-transform-ready"));
 function htmlToTransformReady(html, siteUrl, itemPath, options) {
-    if (typeof itemPath === 'object' && !options) {
-        options = itemPath;
-        itemPath = null;
+    let finalItemPath = null;
+    let finalOptions = options || {};
+    if (typeof itemPath === 'object' && itemPath !== null && !options) {
+        finalOptions = itemPath;
+        finalItemPath = null;
     }
-    const absolute = htmlRelativeToAbsolute(html, siteUrl, itemPath, options);
-    return htmlAbsoluteToTransformReady(absolute, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const absolute = (0, html_relative_to_absolute_1.default)(html, siteUrl, finalItemPath, finalOptions);
+    return (0, html_absolute_to_transform_ready_1.default)(absolute, siteUrl, finalOptions);
 }
-
-module.exports = htmlToTransformReady;
+exports.default = htmlToTransformReady;

package/lib/utils/html-transform.d.ts

@@ -0,0 +1,3 @@
+import type { HtmlTransformOptionsInput, UrlTransformFunction } from './types';
+declare function htmlTransform(html: string | undefined, siteUrl: string, transformFunction: UrlTransformFunction, itemPath: string | null, _options?: HtmlTransformOptionsInput): string;
+export default htmlTransform;