@tryghost/url-utils 5.0.0 → 5.1.0

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

@@ -1,8 +1,10 @@
 "use strict";
-// @ts-nocheck
-// require the whatwg compatible URL library (same behaviour in node and browser)
-const { URL } = require('url');
-const stripSubdirectoryFromPath = require('./strip-subdirectory-from-path');
+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.
  *
@@ -30,8 +32,8 @@ const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options =
     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;
@@ -40,16 +42,19 @@ const absoluteToRelative = function absoluteToRelative(url, rootUrl, _options =
     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

@@ -1,4 +1,13 @@
-declare const URL: any;
-declare const absoluteToRelative: any;
-declare function isRelative(url: any): boolean;
-declare const absoluteToTransformReady: (url: any, root: any, _options?: {}) => any;
+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,11 +1,14 @@
 "use strict";
-// @ts-nocheck
-const { URL } = require('url');
-const absoluteToRelative = require('./absolute-to-relative');
+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 {
-        parsedInput = new URL(url, 'http://relative');
+        parsedInput = new url_1.URL(url, 'http://relative');
     }
     catch (e) {
         // url was unparseable
@@ -22,7 +25,9 @@ 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);
     if (isRelative(url)) {
@@ -30,28 +35,28 @@ const absoluteToTransformReady = function (url, root, _options = {}) {
     }
     // convert to relative with stripped subdir
     // always returns root-relative starting with forward slash
-    const rootRelativeUrl = absoluteToRelative(url, root, options);
+    const rootRelativeUrl = (0, absolute_to_relative_1.default)(url, root, options);
     if (isRelative(rootRelativeUrl)) {
         return `${options.replacementStr}${rootRelativeUrl}`;
     }
     if (options.mediaBaseUrl) {
-        const mediaRelativeUrl = absoluteToRelative(url, options.mediaBaseUrl, options);
+        const mediaRelativeUrl = (0, absolute_to_relative_1.default)(url, options.mediaBaseUrl, options);
         if (isRelative(mediaRelativeUrl)) {
             return `${options.replacementStr}${mediaRelativeUrl}`;
         }
     }
     if (options.filesBaseUrl) {
-        const filesRelativeUrl = absoluteToRelative(url, options.filesBaseUrl, options);
+        const filesRelativeUrl = (0, absolute_to_relative_1.default)(url, options.filesBaseUrl, options);
         if (isRelative(filesRelativeUrl)) {
             return `${options.replacementStr}${filesRelativeUrl}`;
         }
     }
     if (options.imageBaseUrl) {
-        const imageRelativeUrl = absoluteToRelative(url, options.imageBaseUrl, options);
+        const imageRelativeUrl = (0, absolute_to_relative_1.default)(url, options.imageBaseUrl, options);
         if (isRelative(imageRelativeUrl)) {
             return `${options.replacementStr}${imageRelativeUrl}`;
         }
     }
     return url;
 };
-module.exports = absoluteToTransformReady;
+exports.default = absoluteToTransformReady;

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

@@ -1,3 +1,8 @@
+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,
@@ -11,4 +16,9 @@
  * @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: any, options?: {}): any;
+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

@@ -1,5 +1,5 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -18,12 +18,12 @@ function escapeRegExp(string) {
  */
 function buildEarlyExitMatch(siteUrl, options = {}) {
     const candidates = [siteUrl, options.imageBaseUrl, options.filesBaseUrl, options.mediaBaseUrl]
-        .filter(Boolean)
+        .filter((value) => typeof value === 'string' && value.length > 0)
         .map((value) => {
         let normalized = options.ignoreProtocol ? value.replace(/http:|https:/, '') : value;
         return normalized.replace(/\/$/, '');
     })
-        .filter(Boolean)
+        .filter((value) => Boolean(value))
         .map(escapeRegExp);
     if (!candidates.length) {
         return null;
@@ -33,7 +33,7 @@ function buildEarlyExitMatch(siteUrl, options = {}) {
     }
     return `(?:${candidates.join('|')})`;
 }
-module.exports = {
+exports.default = {
     buildEarlyExitMatch,
     escapeRegExp
 };

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

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

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

@@ -1,9 +1,9 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 function deduplicateDoubleSlashes(url) {
     // 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

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

package/lib/utils/deduplicate-subdirectory.js

@@ -1,6 +1,6 @@
 "use strict";
-// @ts-nocheck
-const { URL } = require('url');
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 /**
  * Remove duplicated directories from the start of a path or url's path
  *
@@ -13,7 +13,7 @@ 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;
@@ -24,4 +24,4 @@ const deduplicateSubdirectory = function deduplicateSubdirectory(url, rootUrl) {
     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

@@ -1,3 +1,3 @@
-declare const htmlTransform: any;
-declare const absoluteToRelative: any;
-declare function htmlAbsoluteToRelative(html: string | undefined, siteUrl: any, _options: any): any;
+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,8 +1,11 @@
 "use strict";
-// @ts-nocheck
-const htmlTransform = require('./html-transform');
-const absoluteToRelative = require('./absolute-to-relative');
-function htmlAbsoluteToRelative(html = '', siteUrl, _options) {
+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
@@ -10,8 +13,8 @@ function htmlAbsoluteToRelative(html = '', siteUrl, _options) {
     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

@@ -1,4 +1,3 @@
-declare const htmlTransform: any;
-declare const absoluteToTransformReady: any;
-declare const buildEarlyExitMatch: any;
-declare const htmlAbsoluteToTransformReady: (html: string | undefined, siteUrl: any, _options: any) => any;
+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,17 +1,24 @@
 "use strict";
-// @ts-nocheck
-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) {
+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

@@ -1,3 +1,3 @@
-declare const htmlTransform: any;
-declare const relativeToAbsolute: any;
-declare function htmlRelativeToAbsolute(html: string | undefined, siteUrl: any, itemPath: any, _options: any): any;
+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,8 +1,11 @@
 "use strict";
-// @ts-nocheck
-const htmlTransform = require('./html-transform');
-const relativeToAbsolute = require('./relative-to-absolute');
-function htmlRelativeToAbsolute(html = '', siteUrl, itemPath, _options) {
+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
@@ -10,6 +13,6 @@ function htmlRelativeToAbsolute(html = '', siteUrl, itemPath, _options) {
     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

@@ -1,3 +1,3 @@
-declare const htmlTransform: any;
-declare const relativeToTransformReady: any;
-declare const htmlRelativeToTransformReady: (html: string | undefined, root: any, itemPath: any, _options: any) => any;
+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,12 +1,20 @@
 "use strict";
-// @ts-nocheck
-const htmlTransform = require('./html-transform');
-const relativeToTransformReady = require('./relative-to-transform-ready');
+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__'
@@ -14,12 +22,12 @@ const htmlRelativeToTransformReady = function (html = '', root, itemPath, _optio
     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

@@ -1,3 +1,3 @@
-declare const htmlRelativeToAbsolute: any;
-declare const htmlAbsoluteToTransformReady: any;
-declare function htmlToTransformReady(html: any, siteUrl: any, itemPath: any, options: any): any;
+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 @@
 "use strict";
-// @ts-nocheck
-const htmlRelativeToAbsolute = require('./html-relative-to-absolute');
-const htmlAbsoluteToTransformReady = require('./html-absolute-to-transform-ready');
+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

@@ -1,4 +1,3 @@
-declare const cheerio: any;
-declare function extractSrcsetUrls(srcset?: string): string[];
-declare function extractStyleUrls(style?: string): string[];
-declare function htmlTransform(html: string | undefined, siteUrl: any, transformFunction: any, itemPath: any, _options: any): string;
+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;

package/lib/utils/html-transform.js

@@ -1,5 +1,5 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 const cheerio = require('cheerio');
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -18,23 +18,16 @@ function extractStyleUrls(style = '') {
     }
     return urls;
 }
-function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options) {
-    const defaultOptions = { assetsOnly: false, secure: false };
+function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options = {}) {
+    const defaultOptions = {
+        assetsOnly: false,
+        secure: false
+    };
     const options = Object.assign({}, defaultOptions, _options || {});
     if (!html || (options.earlyExitMatchStr && !html.match(new RegExp(options.earlyExitMatchStr)))) {
         return html;
     }
     const htmlContent = cheerio.load(html, { decodeEntities: false });
-    // replacements is keyed with the attr name + original relative value so
-    // that we can implement skips for untouchable urls
-    //
-    // replacements = {
-    //     'href="/test"': [
-    //         {name: 'href', originalValue: '/test', absoluteValue: '.../test'},
-    //         {name: 'href', originalValue: '/test', skip: true}, // found inside a <code> element
-    //         {name: 'href', originalValue: '/test', absoluteValue: '.../test'},
-    //     ]
-    // }
     const replacements = {};
     function addReplacement(replacement) {
         const key = `${replacement.name}="${replacement.originalValue}"`;
@@ -47,7 +40,8 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
     ['href', 'src', 'srcset', 'style'].forEach((attributeName) => {
         htmlContent('[' + attributeName + ']').each((ix, el) => {
             // ignore <stream> elems and html inside of <code> elements
-            if (el.name === 'stream' || htmlContent(el).closest('code').length) {
+            const elementName = 'name' in el ? el.name : null;
+            if (elementName === 'stream' || htmlContent(el).closest('code').length) {
                 addReplacement({
                     name: attributeName,
                     originalValue: htmlContent(el).attr(attributeName),
@@ -55,8 +49,8 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
                 });
                 return;
             }
-            el = htmlContent(el);
-            const originalValue = el.attr(attributeName);
+            const elWrapper = htmlContent(el);
+            const originalValue = elWrapper.attr(attributeName);
             if (attributeName === 'srcset' || attributeName === 'style') {
                 let urls;
                 if (attributeName === 'srcset') {
@@ -65,11 +59,11 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
                 else {
                     urls = extractStyleUrls(originalValue);
                 }
-                const absoluteUrls = urls.map(url => transformFunction(url, siteUrl, itemPath, options));
+                const absoluteUrls = urls.map((url) => transformFunction(url, siteUrl, itemPath, options));
                 let transformedValue = originalValue;
                 urls.forEach((url, i) => {
                     if (absoluteUrls[i]) {
-                        let regex = new RegExp(escapeRegExp(url), 'g');
+                        const regex = new RegExp(escapeRegExp(url), 'g');
                         transformedValue = transformedValue.replace(regex, absoluteUrls[i]);
                     }
                 });
@@ -102,6 +96,11 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
                 skipCount += 1;
                 return;
             }
+            // transformedValue is guaranteed to exist here because we only add replacements
+            // when transformedValue !== originalValue, and we've already skipped entries with skip: true
+            if (!transformedValue) {
+                return;
+            }
             // this regex avoids matching unrelated plain text by checking that the attribute/value pair
             // is surrounded by <> - that should be sufficient because if the plain text had that wrapper
             // it would be parsed as a tag
@@ -120,4 +119,4 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
     }
     return html;
 }
-module.exports = htmlTransform;
+exports.default = htmlTransform;

package/lib/utils/index.d.ts

@@ -0,0 +1,76 @@
+import absoluteToRelative from './absolute-to-relative';
+import absoluteToTransformReady from './absolute-to-transform-ready';
+import deduplicateDoubleSlashes from './deduplicate-double-slashes';
+import deduplicateSubdirectory from './deduplicate-subdirectory';
+import htmlAbsoluteToRelative from './html-absolute-to-relative';
+import htmlAbsoluteToTransformReady from './html-absolute-to-transform-ready';
+import htmlRelativeToAbsolute from './html-relative-to-absolute';
+import htmlRelativeToTransformReady from './html-relative-to-transform-ready';
+import htmlToTransformReady from './html-to-transform-ready';
+import isSSL from './is-ssl';
+import lexicalAbsoluteToRelative from './lexical-absolute-to-relative';
+import lexicalAbsoluteToTransformReady from './lexical-absolute-to-transform-ready';
+import lexicalRelativeToAbsolute from './lexical-relative-to-absolute';
+import lexicalRelativeToTransformReady from './lexical-relative-to-transform-ready';
+import lexicalToTransformReady from './lexical-to-transform-ready';
+import markdownAbsoluteToRelative from './markdown-absolute-to-relative';
+import markdownRelativeToAbsolute from './markdown-relative-to-absolute';
+import markdownAbsoluteToTransformReady from './markdown-absolute-to-transform-ready';
+import markdownRelativeToTransformReady from './markdown-relative-to-transform-ready';
+import markdownToTransformReady from './markdown-to-transform-ready';
+import mobiledocAbsoluteToRelative from './mobiledoc-absolute-to-relative';
+import mobiledocRelativeToAbsolute from './mobiledoc-relative-to-absolute';
+import mobiledocAbsoluteToTransformReady from './mobiledoc-absolute-to-transform-ready';
+import mobiledocRelativeToTransformReady from './mobiledoc-relative-to-transform-ready';
+import mobiledocToTransformReady from './mobiledoc-to-transform-ready';
+import plaintextAbsoluteToTransformReady from './plaintext-absolute-to-transform-ready';
+import plaintextRelativeToTransformReady from './plaintext-relative-to-transform-ready';
+import plaintextToTransformReady from './plaintext-to-transform-ready';
+import relativeToAbsolute from './relative-to-absolute';
+import relativeToTransformReady from './relative-to-transform-ready';
+import replacePermalink from './replace-permalink';
+import stripSubdirectoryFromPath from './strip-subdirectory-from-path';
+import toTransformReady from './to-transform-ready';
+import transformReadyToAbsolute from './transform-ready-to-absolute';
+import transformReadyToRelative from './transform-ready-to-relative';
+import urlJoin from './url-join';
+export { absoluteToRelative, absoluteToTransformReady, deduplicateDoubleSlashes, deduplicateSubdirectory, htmlAbsoluteToRelative, htmlRelativeToAbsolute, htmlAbsoluteToTransformReady, htmlRelativeToTransformReady, htmlToTransformReady, isSSL, lexicalAbsoluteToRelative, lexicalAbsoluteToTransformReady, lexicalRelativeToAbsolute, lexicalRelativeToTransformReady, lexicalToTransformReady, markdownAbsoluteToRelative, markdownRelativeToAbsolute, markdownAbsoluteToTransformReady, markdownRelativeToTransformReady, markdownToTransformReady, mobiledocAbsoluteToRelative, mobiledocRelativeToAbsolute, mobiledocAbsoluteToTransformReady, mobiledocRelativeToTransformReady, mobiledocToTransformReady, plaintextAbsoluteToTransformReady, plaintextRelativeToTransformReady, plaintextToTransformReady, relativeToAbsolute, relativeToTransformReady, replacePermalink, stripSubdirectoryFromPath, toTransformReady, transformReadyToAbsolute, transformReadyToRelative, urlJoin };
+declare const utils: {
+    absoluteToRelative: (url: string, rootUrl?: string, _options?: import("./absolute-to-relative").AbsoluteToRelativeOptionsInput) => string;
+    absoluteToTransformReady: (url: string, root: string, _options?: import("./absolute-to-transform-ready").AbsoluteToTransformReadyOptionsInput) => string;
+    deduplicateDoubleSlashes: typeof deduplicateDoubleSlashes;
+    deduplicateSubdirectory: (url: string, rootUrl: string) => string;
+    htmlAbsoluteToRelative: typeof htmlAbsoluteToRelative;
+    htmlRelativeToAbsolute: typeof htmlRelativeToAbsolute;
+    htmlAbsoluteToTransformReady: (html: string | undefined, siteUrl: string, _options?: import("./types").AbsoluteToTransformReadyOptionsInput) => string;
+    htmlRelativeToTransformReady: (html: string | undefined, root: string, itemPath: string | null | import("./relative-to-transform-ready").RelativeToTransformReadyOptionsInput, _options?: import("./relative-to-transform-ready").RelativeToTransformReadyOptionsInput) => string;
+    htmlToTransformReady: typeof htmlToTransformReady;
+    isSSL: typeof isSSL;
+    lexicalAbsoluteToRelative: typeof lexicalAbsoluteToRelative;
+    lexicalRelativeToAbsolute: typeof lexicalRelativeToAbsolute;
+    lexicalAbsoluteToTransformReady: typeof lexicalAbsoluteToTransformReady;
+    lexicalRelativeToTransformReady: typeof lexicalRelativeToTransformReady;
+    lexicalToTransformReady: typeof lexicalToTransformReady;
+    markdownAbsoluteToRelative: typeof markdownAbsoluteToRelative;
+    markdownAbsoluteToTransformReady: typeof markdownAbsoluteToTransformReady;
+    markdownRelativeToAbsolute: typeof markdownRelativeToAbsolute;
+    markdownRelativeToTransformReady: typeof markdownRelativeToTransformReady;
+    markdownToTransformReady: typeof markdownToTransformReady;
+    mobiledocAbsoluteToRelative: typeof mobiledocAbsoluteToRelative;
+    mobiledocAbsoluteToTransformReady: typeof mobiledocAbsoluteToTransformReady;
+    mobiledocRelativeToAbsolute: typeof mobiledocRelativeToAbsolute;
+    mobiledocRelativeToTransformReady: typeof mobiledocRelativeToTransformReady;
+    mobiledocToTransformReady: typeof mobiledocToTransformReady;
+    plaintextAbsoluteToTransformReady: (plaintext: string, rootUrl: string, itemPath: string | null | Partial<Partial<import("./types").AbsoluteToTransformReadyOptions> & Partial<import("./types").BaseUrlOptions>>, options?: Partial<Partial<import("./types").AbsoluteToTransformReadyOptions> & Partial<import("./types").BaseUrlOptions>>) => string;
+    plaintextRelativeToTransformReady: (plaintext: string, rootUrl: string, itemPath: string | null | import("./relative-to-transform-ready").RelativeToTransformReadyOptionsInput, options?: import("./relative-to-transform-ready").RelativeToTransformReadyOptionsInput) => string;
+    plaintextToTransformReady: typeof plaintextToTransformReady;
+    relativeToAbsolute: (path: string, rootUrl: string, itemPath: string | null | import("./relative-to-absolute").RelativeToAbsoluteOptionsInput, _options?: import("./relative-to-absolute").RelativeToAbsoluteOptionsInput) => string;
+    relativeToTransformReady: (url: string, root: string, itemPath: string | null | import("./relative-to-transform-ready").RelativeToTransformReadyOptionsInput, _options?: import("./relative-to-transform-ready").RelativeToTransformReadyOptionsInput) => string;
+    replacePermalink: typeof replacePermalink;
+    stripSubdirectoryFromPath: (path?: string, rootUrl?: string) => string;
+    toTransformReady: typeof toTransformReady;
+    transformReadyToAbsolute: (str: string | undefined, root: string, _options?: import("./transform-ready-to-absolute").TransformReadyToAbsoluteOptionsInput) => string;
+    transformReadyToRelative: (str: string | undefined, root: string, _options?: import("./types").TransformReadyReplacementOptionsInput) => string;
+    urlJoin: typeof urlJoin;
+};
+export default utils;