@tryghost/url-utils 5.0.0 → 5.1.0

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

@@ -1,13 +1,21 @@
 "use strict";
-// @ts-nocheck
-const markdownRelativeToAbsolute = require('./markdown-relative-to-absolute');
-const markdownAbsoluteToTransformReady = require('./markdown-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 markdown_relative_to_absolute_1 = __importDefault(require("./markdown-relative-to-absolute"));
+const markdown_absolute_to_transform_ready_1 = __importDefault(require("./markdown-absolute-to-transform-ready"));
 function markdownToTransformReady(markdown, 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 = markdownRelativeToAbsolute(markdown, siteUrl, itemPath, options);
-    return markdownAbsoluteToTransformReady(absolute, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const absolute = (0, markdown_relative_to_absolute_1.default)(markdown, siteUrl, finalItemPath, finalOptions);
+    return (0, markdown_absolute_to_transform_ready_1.default)(absolute, siteUrl, finalOptions);
 }
-module.exports = markdownToTransformReady;
+exports.default = markdownToTransformReady;

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

@@ -1,5 +1,3 @@
-declare let remark: any;
-declare const footnotes: any;
-declare const visit: any;
-declare function replaceLast(find: any, replace: any, str: any): any;
-declare function markdownTransform(markdown: string | undefined, siteUrl: any, transformFunctions: any, itemPath: any, _options?: {}): string;
+import type { MarkdownTransformOptionsInput, MarkdownTransformFunctions } from './types';
+declare function markdownTransform(markdown: string | undefined, siteUrl: string, transformFunctions: MarkdownTransformFunctions, itemPath: string | null, _options?: MarkdownTransformOptionsInput): string;
+export default markdownTransform;

package/lib/utils/markdown-transform.js

@@ -1,5 +1,5 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 let remark;
 const footnotes = require('remark-footnotes');
 const visit = require('unist-util-visit');
@@ -22,14 +22,17 @@ function markdownTransform(markdown = '', siteUrl, transformFunctions, itemPath,
     if (!remark) {
         remark = require('remark');
     }
+    if (!remark) {
+        return markdown;
+    }
     const tree = remark()
         .use({ settings: { commonmark: true } })
         .use(footnotes, { inlineNotes: true })
         .parse(markdown);
     visit(tree, ['link', 'image', 'html'], (node) => {
-        if (node.type === 'html' && node.value.match(/src|srcset|href/)) {
+        if (node.type === 'html' && node.value && node.value.match(/src|srcset|href/) && node.position) {
             const oldValue = node.value;
-            const newValue = transformFunctions.html(node.value, siteUrl, itemPath, options);
+            const newValue = transformFunctions.html(oldValue, siteUrl, itemPath, options);
             if (newValue !== oldValue) {
                 replacements.push({
                     old: oldValue,
@@ -39,9 +42,9 @@ function markdownTransform(markdown = '', siteUrl, transformFunctions, itemPath,
                 });
             }
         }
-        if (node.type === 'link' || node.type === 'image') {
+        if ((node.type === 'link' || node.type === 'image') && node.url && node.position) {
             const oldValue = node.url;
-            const newValue = transformFunctions.url(node.url, siteUrl, itemPath, options);
+            const newValue = transformFunctions.url(oldValue, siteUrl, itemPath, options);
             if (newValue !== oldValue) {
                 replacements.push({
                     old: oldValue,
@@ -77,4 +80,4 @@ function markdownTransform(markdown = '', siteUrl, transformFunctions, itemPath,
     });
     return result;
 }
-module.exports = markdownTransform;
+exports.default = markdownTransform;

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

@@ -1,2 +1,3 @@
-declare const absoluteToRelative: any;
-declare const mobiledocTransform: any;
+import type { MobiledocTransformOptionsInput } from './types';
+declare function mobiledocAbsoluteToRelative(serializedMobiledoc: string, siteUrl: string, _options?: MobiledocTransformOptionsInput): string;
+export default mobiledocAbsoluteToRelative;

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

@@ -1,14 +1,17 @@
 "use strict";
-// @ts-nocheck
-const absoluteToRelative = require('./absolute-to-relative');
-const mobiledocTransform = require('./mobiledoc-transform');
+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 mobiledoc_transform_1 = __importDefault(require("./mobiledoc-transform"));
 function mobiledocAbsoluteToRelative(serializedMobiledoc, siteUrl, _options = {}) {
     const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
     const overrideOptions = { siteUrl, transformType: 'absoluteToRelative' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
-        return absoluteToRelative(_url, _siteUrl, __options);
+        return (0, absolute_to_relative_1.default)(_url, _siteUrl, __options);
     };
-    return mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, '', options);
+    return (0, mobiledoc_transform_1.default)(serializedMobiledoc, siteUrl, transformFunction, '', options);
 }
-module.exports = mobiledocAbsoluteToRelative;
+exports.default = mobiledocAbsoluteToRelative;

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

@@ -1,2 +1,3 @@
-declare const absoluteToTransformReady: any;
-declare const mobiledocTransform: any;
+import type { MobiledocTransformOptionsInput } from './types';
+declare function mobiledocAbsoluteToTransformReady(serializedMobiledoc: string, siteUrl: string, _options?: MobiledocTransformOptionsInput): string;
+export default mobiledocAbsoluteToTransformReady;

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

@@ -1,14 +1,17 @@
 "use strict";
-// @ts-nocheck
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-const mobiledocTransform = require('./mobiledoc-transform');
-function mobiledocAbsoluteToRelative(serializedMobiledoc, siteUrl, _options = {}) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
+const mobiledoc_transform_1 = __importDefault(require("./mobiledoc-transform"));
+function mobiledocAbsoluteToTransformReady(serializedMobiledoc, siteUrl, _options = {}) {
     const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
     const overrideOptions = { siteUrl, transformType: 'toTransformReady' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
-        return absoluteToTransformReady(_url, _siteUrl, __options);
+        return (0, absolute_to_transform_ready_1.default)(_url, _siteUrl, __options);
     };
-    return mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, '', options);
+    return (0, mobiledoc_transform_1.default)(serializedMobiledoc, siteUrl, transformFunction, '', options);
 }
-module.exports = mobiledocAbsoluteToRelative;
+exports.default = mobiledocAbsoluteToTransformReady;

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

@@ -1,3 +1,3 @@
-declare const relativeToAbsolute: any;
-declare const mobiledocTransform: any;
-declare function mobiledocRelativeToAbsolute(serializedMobiledoc: any, siteUrl: any, itemPath: any, _options?: {}): any;
+import type { MobiledocTransformOptionsInput } from './types';
+declare function mobiledocRelativeToAbsolute(serializedMobiledoc: string, siteUrl: string, itemPath: string | null, _options?: MobiledocTransformOptionsInput): string;
+export default mobiledocRelativeToAbsolute;

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

@@ -1,11 +1,14 @@
 "use strict";
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
-const mobiledocTransform = require('./mobiledoc-transform');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+const mobiledoc_transform_1 = __importDefault(require("./mobiledoc-transform"));
 function mobiledocRelativeToAbsolute(serializedMobiledoc, siteUrl, itemPath, _options = {}) {
     const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
     const overrideOptions = { siteUrl, itemPath, transformType: 'relativeToAbsolute' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-    return mobiledocTransform(serializedMobiledoc, siteUrl, relativeToAbsolute, itemPath, options);
+    return (0, mobiledoc_transform_1.default)(serializedMobiledoc, siteUrl, relative_to_absolute_1.default, itemPath, options);
 }
-module.exports = mobiledocRelativeToAbsolute;
+exports.default = mobiledocRelativeToAbsolute;

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

@@ -1,3 +1,3 @@
-declare const relativeToTransformReady: any;
-declare const mobiledocTransform: any;
-declare function mobiledocRelativeToTransformReady(serializedMobiledoc: any, siteUrl: any, itemPath: any, _options?: {}): any;
+import type { MobiledocTransformOptionsInput } from './types';
+declare function mobiledocRelativeToTransformReady(serializedMobiledoc: string, siteUrl: string, itemPath: string | null, _options?: MobiledocTransformOptionsInput): string;
+export default mobiledocRelativeToTransformReady;

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

@@ -1,11 +1,14 @@
 "use strict";
-// @ts-nocheck
-const relativeToTransformReady = require('./relative-to-transform-ready');
-const mobiledocTransform = require('./mobiledoc-transform');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const relative_to_transform_ready_1 = __importDefault(require("./relative-to-transform-ready"));
+const mobiledoc_transform_1 = __importDefault(require("./mobiledoc-transform"));
 function mobiledocRelativeToTransformReady(serializedMobiledoc, siteUrl, itemPath, _options = {}) {
     const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
     const overrideOptions = { siteUrl, transformType: 'toTransformReady' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-    return mobiledocTransform(serializedMobiledoc, siteUrl, relativeToTransformReady, itemPath, options);
+    return (0, mobiledoc_transform_1.default)(serializedMobiledoc, siteUrl, relative_to_transform_ready_1.default, itemPath, options);
 }
-module.exports = mobiledocRelativeToTransformReady;
+exports.default = mobiledocRelativeToTransformReady;

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

@@ -1,3 +1,3 @@
-declare const mobiledocRelativeToAbsolute: any;
-declare const mobiledocAbsoluteToTransformReady: any;
-declare function mobiledocToTransformReady(mobiledoc: any, siteUrl: any, itemPath: any, options: any): any;
+import type { MobiledocTransformOptionsInput } from './types';
+declare function mobiledocToTransformReady(mobiledoc: string, siteUrl: string, itemPath: string | null | MobiledocTransformOptionsInput, options?: MobiledocTransformOptionsInput): string;
+export default mobiledocToTransformReady;

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

@@ -1,13 +1,21 @@
 "use strict";
-// @ts-nocheck
-const mobiledocRelativeToAbsolute = require('./mobiledoc-relative-to-absolute');
-const mobiledocAbsoluteToTransformReady = require('./mobiledoc-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 mobiledoc_relative_to_absolute_1 = __importDefault(require("./mobiledoc-relative-to-absolute"));
+const mobiledoc_absolute_to_transform_ready_1 = __importDefault(require("./mobiledoc-absolute-to-transform-ready"));
 function mobiledocToTransformReady(mobiledoc, 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 = mobiledocRelativeToAbsolute(mobiledoc, siteUrl, itemPath, options);
-    return mobiledocAbsoluteToTransformReady(absolute, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const absolute = (0, mobiledoc_relative_to_absolute_1.default)(mobiledoc, siteUrl, finalItemPath, finalOptions);
+    return (0, mobiledoc_absolute_to_transform_ready_1.default)(absolute, siteUrl, finalOptions);
 }
-module.exports = mobiledocToTransformReady;
+exports.default = mobiledocToTransformReady;

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

@@ -1 +1,3 @@
-declare function mobiledocTransform(serializedMobiledoc: any, siteUrl: any, transformFunction: any, itemPath: any, _options?: {}): string;
+import type { MobiledocTransformOptionsInput, UrlTransformFunction } from './types';
+declare function mobiledocTransform(serializedMobiledoc: string, siteUrl: string, transformFunction: UrlTransformFunction, itemPath: string | null, _options?: MobiledocTransformOptionsInput): string;
+export default mobiledocTransform;

package/lib/utils/mobiledoc-transform.js

@@ -1,5 +1,5 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 function mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, itemPath, _options = {}) {
     const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
     const options = Object.assign({}, defaultOptions, _options, { siteUrl, itemPath });
@@ -25,7 +25,7 @@ function mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, ite
                     hrefIndex = index + 1;
                 }
             });
-            if (hrefIndex !== -1) {
+            if (hrefIndex !== -1 && typeof markup[1][hrefIndex] === 'string') {
                 const transformedUrl = transformFunction(markup[1][hrefIndex], siteUrl, itemPath, options);
                 if (transformedUrl) {
                     markup[1][hrefIndex] = transformedUrl;
@@ -37,7 +37,8 @@ function mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, ite
     // cards may contain so we sub out to card-specific transform functions that
     // are passed in as options from the consuming application.
     (mobiledoc.cards || []).forEach((card) => {
-        const [name, payload] = card;
+        const name = card[0];
+        const payload = card[1];
         if (cardTransformers[name]) {
             // transformers take a payload and return a transformed payload
             const transformedPayload = cardTransformers[name](payload, options);
@@ -46,4 +47,4 @@ function mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, ite
     });
     return JSON.stringify(mobiledoc);
 }
-module.exports = mobiledocTransform;
+exports.default = mobiledocTransform;

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

@@ -1,4 +1,5 @@
-declare const absoluteToTransformReady: any;
-declare const escapeRegExp: any;
-declare function buildLinkRegex(rootUrl: any, options?: {}): RegExp | null;
-declare const plaintextAbsoluteToTransformReady: (plaintext: any, rootUrl: any, itemPath: any, options: any) => any;
+import type { AbsoluteToTransformReadyOptionsInput, BaseUrlOptionsInput } from './types';
+type PlaintextAbsoluteToTransformReadyOptions = AbsoluteToTransformReadyOptionsInput & BaseUrlOptionsInput;
+type PlaintextAbsoluteToTransformReadyOptionsInput = Partial<PlaintextAbsoluteToTransformReadyOptions>;
+declare const plaintextAbsoluteToTransformReady: (plaintext: string, rootUrl: string, itemPath: string | null | PlaintextAbsoluteToTransformReadyOptionsInput, options?: PlaintextAbsoluteToTransformReadyOptionsInput) => string;
+export default plaintextAbsoluteToTransformReady;

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

@@ -1,13 +1,18 @@
 "use strict";
-// @ts-nocheck
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-const { escapeRegExp } = require('./build-early-exit-match');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 { escapeRegExp } = build_early_exit_match_1.default;
+const url_1 = require("url");
 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);
+        .filter((value) => Boolean(value));
     const patterns = baseUrls.map((baseUrl) => {
-        const parsed = new URL(baseUrl);
+        const parsed = new url_1.URL(baseUrl);
         const escapedUrl = escapeRegExp(`${parsed.hostname}${parsed.pathname.replace(/\/$/, '')}`);
         return escapedUrl;
     });
@@ -19,16 +24,16 @@ function buildLinkRegex(rootUrl, options = {}) {
 }
 const plaintextAbsoluteToTransformReady = function plaintextAbsoluteToTransformReady(plaintext, rootUrl, 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 finalOptions = options || {};
+    if (typeof itemPath === 'object' && itemPath !== null && !options) {
+        finalOptions = itemPath;
     }
     // plaintext links look like "Link title [url]"
     // those links are all we care about so we can do a fast regex here
-    const linkRegex = buildLinkRegex(rootUrl, options);
+    const linkRegex = buildLinkRegex(rootUrl, finalOptions);
     return plaintext.replace(linkRegex, function (fullMatch, url) {
-        const newUrl = absoluteToTransformReady(`${url}`, rootUrl, options);
+        const newUrl = (0, absolute_to_transform_ready_1.default)(`${url}`, rootUrl, finalOptions);
         return ` [${newUrl}]`;
     });
 };
-module.exports = plaintextAbsoluteToTransformReady;
+exports.default = plaintextAbsoluteToTransformReady;

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

@@ -1,2 +1,3 @@
-declare const relativeToTransformReady: any;
-declare const plaintextRelativeToTransformReady: (plaintext: any, rootUrl: any, itemPath: any, options: any) => any;
+import type { RelativeToTransformReadyOptionsInput } from './relative-to-transform-ready';
+declare const plaintextRelativeToTransformReady: (plaintext: string, rootUrl: string, itemPath: string | null | RelativeToTransformReadyOptionsInput, options?: RelativeToTransformReadyOptionsInput) => string;
+export default plaintextRelativeToTransformReady;

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

@@ -1,17 +1,25 @@
 "use strict";
-// @ts-nocheck
-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 relative_to_transform_ready_1 = __importDefault(require("./relative-to-transform-ready"));
 const plaintextRelativeToTransformReady = function plaintextRelativeToTransformReady(plaintext, rootUrl, 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;
     }
     // plaintext links look like "Link title [url]"
     // those are all we care about so we can do a fast regex here
     return plaintext.replace(/ \[(\/.*?)\]/g, function (fullMatch, path) {
-        const newPath = relativeToTransformReady(`${path}`, rootUrl, itemPath, options);
+        const newPath = (0, relative_to_transform_ready_1.default)(`${path}`, rootUrl, finalItemPath, finalOptions);
         return ` [${newPath}]`;
     });
 };
-module.exports = plaintextRelativeToTransformReady;
+exports.default = plaintextRelativeToTransformReady;

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

@@ -1,3 +1,5 @@
-declare const plaintextRelativeToTransformReady: any;
-declare const plaintextAbsoluteToTransformReady: any;
-declare function plaintextToTransformReady(plaintext: any, siteUrl: any, itemPath: any, options: any): any;
+import type { UnknownRecord } from './types';
+type PlaintextTransformOptions = UnknownRecord;
+type PlaintextTransformOptionsInput = Partial<PlaintextTransformOptions>;
+declare function plaintextToTransformReady(plaintext: string, siteUrl: string, itemPath: string | null | PlaintextTransformOptionsInput, options?: PlaintextTransformOptionsInput): string;
+export default plaintextToTransformReady;

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

@@ -1,13 +1,21 @@
 "use strict";
-// @ts-nocheck
-const plaintextRelativeToTransformReady = require('./plaintext-relative-to-transform-ready');
-const plaintextAbsoluteToTransformReady = require('./plaintext-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 plaintext_relative_to_transform_ready_1 = __importDefault(require("./plaintext-relative-to-transform-ready"));
+const plaintext_absolute_to_transform_ready_1 = __importDefault(require("./plaintext-absolute-to-transform-ready"));
 function plaintextToTransformReady(plaintext, 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 relativeTransformed = plaintextRelativeToTransformReady(plaintext, siteUrl, itemPath, options);
-    return plaintextAbsoluteToTransformReady(relativeTransformed, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const relativeTransformed = (0, plaintext_relative_to_transform_ready_1.default)(plaintext, siteUrl, finalItemPath, finalOptions);
+    return (0, plaintext_absolute_to_transform_ready_1.default)(relativeTransformed, siteUrl, finalOptions);
 }
-module.exports = plaintextToTransformReady;
+exports.default = plaintextToTransformReady;

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

@@ -1,5 +1,6 @@
-declare const URL: any;
-declare const urlJoin: any;
+import type { SecureOptions, SecureOptionsInput } from './types';
+export type RelativeToAbsoluteOptions = SecureOptions;
+export type RelativeToAbsoluteOptionsInput = SecureOptionsInput;
 /**
  * Convert a root-relative path to an absolute URL based on the supplied root.
  * Will _only_ convert root-relative urls (/some/path not some/path)
@@ -10,4 +11,5 @@ declare const urlJoin: any;
  * @param {object} options
  * @returns {string} The passed in url or an absolute URL using
  */
-declare const relativeToAbsolute: (path: any, rootUrl: any, itemPath: any, _options: any) => any;
+declare const relativeToAbsolute: (path: string, rootUrl: string, itemPath: string | null | RelativeToAbsoluteOptionsInput, _options?: RelativeToAbsoluteOptionsInput) => string;
+export default relativeToAbsolute;

package/lib/utils/relative-to-absolute.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 urlJoin = require('./url-join');
+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 url_join_1 = __importDefault(require("./url-join"));
 // NOTE: Ghost's relative->absolute handling is a little strange when the rootUrl
 // includes a subdirectory. Root-relative paths such as /content/image.jpg are
 // actually treated as subdirectory-relative. This means that it's possible to
@@ -23,20 +25,25 @@ const urlJoin = require('./url-join');
  */
 const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath, _options) {
     // itemPath is optional, if it's an object it 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;
     }
     // itemPath could be sent as a full url in which case, extract the pathname
-    if (itemPath && itemPath.match(/^http/)) {
-        const itemUrl = new URL(itemPath);
-        itemPath = itemUrl.pathname;
+    if (finalItemPath && finalItemPath.match(/^http/)) {
+        const itemUrl = new url_1.URL(finalItemPath);
+        finalItemPath = itemUrl.pathname;
     }
     const defaultOptions = {
         assetsOnly: false,
         staticImageUrlPrefix: 'content/images'
     };
-    const options = Object.assign({}, defaultOptions, _options);
+    const options = Object.assign({}, defaultOptions, finalOptions);
     // return the path as-is if it's not an asset path and we're only modifying assets
     if (options.assetsOnly) {
         const staticImageUrlPrefixRegex = new RegExp(options.staticImageUrlPrefix);
@@ -46,7 +53,7 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
     }
     // if URL is absolute return it as-is
     try {
-        const parsed = new URL(path, 'http://relative');
+        const parsed = new url_1.URL(path, 'http://relative');
         if (parsed.origin !== 'http://relative') {
             return path;
         }
@@ -63,20 +70,20 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
         return path;
     }
     // return the path as-is if it's not root-relative and we have no itemPath
-    if (!itemPath && !path.match(/^\//)) {
+    if (!finalItemPath && !path.match(/^\//)) {
         return path;
     }
     // force root to always have a trailing-slash for consistent behaviour
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-    const parsedRootUrl = new URL(rootUrl);
-    const basePath = path.startsWith('/') ? '' : itemPath;
-    const fullPath = urlJoin([parsedRootUrl.pathname, basePath, path], { rootUrl });
-    const absoluteUrl = new URL(fullPath, rootUrl);
+    const parsedRootUrl = new url_1.URL(rootUrl);
+    const basePath = path.startsWith('/') ? '' : (finalItemPath || '');
+    const fullPath = (0, url_join_1.default)([parsedRootUrl.pathname, basePath, path], { rootUrl });
+    const absoluteUrl = new url_1.URL(fullPath, rootUrl);
     if (options.secure) {
         absoluteUrl.protocol = 'https:';
     }
     return absoluteUrl.toString();
 };
-module.exports = relativeToAbsolute;
+exports.default = relativeToAbsolute;

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

@@ -1,2 +1,8 @@
-declare const relativeToAbsolute: any;
-declare const relativeToTransformReady: (url: any, root: any, itemPath: any, _options: any) => any;
+import type { TransformReadyReplacementOptions } from './types';
+export interface RelativeToTransformReadyOptions extends TransformReadyReplacementOptions {
+    staticImageUrlPrefix: string;
+    secure: boolean;
+}
+export type RelativeToTransformReadyOptionsInput = Partial<RelativeToTransformReadyOptions>;
+declare const relativeToTransformReady: (url: string, root: string, itemPath: string | null | RelativeToTransformReadyOptionsInput, _options?: RelativeToTransformReadyOptionsInput) => string;
+export default relativeToTransformReady;

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

@@ -1,11 +1,20 @@
 "use strict";
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+const url_1 = require("url");
 const relativeToTransformReady = function (url, 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,22 +23,25 @@ const relativeToTransformReady = function (url, root, itemPath, _options) {
     const overrideOptions = {
         secure: false
     };
-    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+    const options = Object.assign({}, defaultOptions, finalOptions, overrideOptions);
     // convert to absolute
-    const absoluteUrl = relativeToAbsolute(url, root, itemPath, options);
+    const absoluteUrl = (0, relative_to_absolute_1.default)(url, root, finalItemPath, options);
     if (absoluteUrl === url) {
         return url;
     }
-    const rootUrl = new URL(root);
+    const rootUrl = new url_1.URL(root);
     const rootPathname = rootUrl.pathname.replace(/\/$/, '');
     // only convert to transform-ready if root url has no subdirectory or the subdirectory matches
     if (!url.match(/^\//) || rootPathname === '' || url.indexOf(rootPathname) === 0 || url.indexOf(`/${options.staticImageUrlPrefix}`) === 0) {
+        // normalize root to match the protocol of absoluteUrl (in case secure option changed it)
+        const absoluteUrlParsed = new url_1.URL(absoluteUrl);
+        const normalizedRoot = `${absoluteUrlParsed.protocol}//${rootUrl.host}${rootUrl.pathname}`.replace(/\/$/, '');
         // replace root with replacement string
         const transformedUrl = absoluteUrl
-            .replace(root, `${options.replacementStr}/`) // always have trailing slash after magic string
+            .replace(normalizedRoot, `${options.replacementStr}/`) // always have trailing slash after magic string
             .replace(/([^:])\/\//g, '$1/');
         return transformedUrl;
     }
     return url;
 };
-module.exports = relativeToTransformReady;
+exports.default = relativeToTransformReady;