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

package/lib/utils/mobiledoc-transform.js

@@ -1,7 +1,8 @@
+"use strict";
+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});
-
+    const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
+    const options = Object.assign({}, defaultOptions, _options, { siteUrl, itemPath });
     // options.cardTransformers has an object for each card that has a name and multiple
     // transformer functions. By collecting the functions we need into a named object it
     // reduces the need to loop through and find the transformer for each card later on
@@ -10,25 +11,21 @@ function mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, ite
         cardTransformers[cardTransformer.name] = cardTransformer[options.transformType];
     });
     delete options.cardTransformers;
-
     // function only accepts serialized mobiledoc so there's no chance of accidentally
     // modifying pass-by-reference objects
     const mobiledoc = JSON.parse(serializedMobiledoc);
-
     // any mobiledoc links will have an 'a' markup with an 'href' attribute
     (mobiledoc.markups || []).forEach((markup) => {
         if (markup[0] === 'a' && markup[1]) {
             // mobiledoc markup attrs are in an array like ['key', 'value', 'key2', 'value2']
             // we only care about the href attr so loop through and find it so we can get the idx of it's value
             let hrefIndex = -1;
-
             markup[1].forEach((attr, index) => {
                 if (attr === 'href') {
                     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;
@@ -36,20 +33,18 @@ function mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, ite
             }
         }
     });
-
     // any other urls will be within card payloads. We can't know what format
     // 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);
             card[1] = transformedPayload;
         }
     });
-
     return JSON.stringify(mobiledoc);
 }
-
-module.exports = mobiledocTransform;
+exports.default = mobiledocTransform;

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

@@ -0,0 +1,5 @@
+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,26 +1,39 @@
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+"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_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((value) => Boolean(value));
+    const patterns = baseUrls.map((baseUrl) => {
+        const parsed = new url_1.URL(baseUrl);
+        const escapedUrl = escapeRegExp(`${parsed.hostname}${parsed.pathname.replace(/\/$/, '')}`);
+        return escapedUrl;
+    });
+    if (!patterns.length) {
+        return null;
+    }
+    const pattern = patterns.length === 1 ? patterns[0] : `(?:${patterns.join('|')})`;
+    return new RegExp(` \\[(https?://${pattern}.*?)\\]`, 'g');
 }
-
 const plaintextAbsoluteToTransformReady = function plaintextAbsoluteToTransformReady(plaintext, rootUrl, itemPath, options) {
     // 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 rootURL = new URL(rootUrl);
-    const escapedRootUrl = escapeRegExp(`${rootURL.hostname}${rootURL.pathname.replace(/\/$/, '')}`);
-    const linkRegex = new RegExp(` \\[(https?://${escapedRootUrl}.*?)\\]`, 'g');
-
+    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

@@ -0,0 +1,3 @@
+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,18 +1,25 @@
-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 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

@@ -0,0 +1,5 @@
+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 @@
-const plaintextRelativeToTransformReady = require('./plaintext-relative-to-transform-ready');
-const plaintextAbsoluteToTransformReady = require('./plaintext-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 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

@@ -0,0 +1,15 @@
+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)
+ *
+ * @param {string} path
+ * @param {string} rootUrl
+ * @param {string} itemPath
+ * @param {object} options
+ * @returns {string} The passed in url or an absolute URL using
+ */
+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,7 +1,10 @@
-// require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
-const urlJoin = require('./url-join');
-
+"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 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
@@ -10,7 +13,6 @@ const urlJoin = require('./url-join');
 // of path styles (/content/image.png and /subdir/content/image.png). To handle
 // this when all root-relative paths are treated as subdir-relative we have to
 // rely on subdirectory deduplication.
-
 /**
  * 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)
@@ -23,23 +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);
@@ -47,48 +51,39 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
             return path;
         }
     }
-
     // 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;
         }
-
         // Do not convert protocol relative URLs
         if (path.lastIndexOf('//', 0) === 0) {
             return path;
         }
-    } catch (e) {
+    }
+    catch (e) {
         return path;
     }
-
     // return the path as-is if it's a pure hash param
     if (path.startsWith('#')) {
         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

@@ -0,0 +1,8 @@
+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,12 +1,21 @@
-const relativeToAbsolute = require('./relative-to-absolute');
-
+"use strict";
+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__',
         staticImageUrlPrefix: 'content/images'
@@ -14,29 +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;

package/lib/utils/replace-permalink.d.ts

@@ -0,0 +1,16 @@
+interface PermalinkResource {
+    published_at?: string | number | Date | null;
+    primary_author?: {
+        slug: string;
+    } | null;
+    primary_tag?: {
+        slug: string;
+    } | null;
+    slug: string;
+    id: string;
+}
+/**
+ * creates the url path for a post based on blog timezone and permalink pattern
+ */
+declare function replacePermalink(permalink: string, resource: PermalinkResource, timezone?: string): string;
+export default replacePermalink;

package/lib/utils/replace-permalink.js

@@ -1,10 +1,43 @@
-const moment = require('moment-timezone');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment = __importStar(require("moment-timezone"));
 /**
  * creates the url path for a post based on blog timezone and permalink pattern
  */
 function replacePermalink(permalink, resource, timezone = 'UTC') {
-    const output = permalink;
     const primaryTagFallback = 'all';
     const publishedAtMoment = moment.tz(resource.published_at || Date.now(), timezone);
     const permalinkLookUp = {
@@ -18,7 +51,7 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
             return publishedAtMoment.format('DD');
         },
         author: function () {
-            return resource.primary_author.slug;
+            return resource.primary_author?.slug ?? 'undefined';
         },
         primary_author: function () {
             return resource.primary_author ? resource.primary_author.slug : primaryTagFallback;
@@ -33,14 +66,16 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
             return resource.id;
         }
     };
-
     // replace tags like :slug or :year with actual values
     const permalinkKeys = Object.keys(permalinkLookUp);
-    return output.replace(/(:[a-z_]+)/g, function (match) {
-        if (permalinkKeys.includes(match.substr(1))) {
-            return permalinkLookUp[match.substr(1)]();
+    return permalink.replace(/(:[a-z_]+)/g, function (match) {
+        const key = match.slice(1);
+        if (permalinkKeys.includes(key)) {
+            // Known route segment - use the lookup function
+            return permalinkLookUp[key]();
         }
+        // Unknown route segment - return 'undefined' string
+        return 'undefined';
     });
 }
-
-module.exports = replacePermalink;
+exports.default = replacePermalink;

package/lib/utils/strip-subdirectory-from-path.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes the directory in the root url from the relative path
+ *
+ * @param {string} path Relative path (eg, '/my/subdir/my/file.png)
+ * @param {string} rootUrl Root URL (eg, 'https://mysite.com/my/subdir/)
+ * @returns {string} Path relative to the rootUrl's path
+ */
+declare const stripSubdirectoryFromPath: (path?: string, rootUrl?: string) => string;
+export default stripSubdirectoryFromPath;

package/lib/utils/strip-subdirectory-from-path.js

@@ -1,5 +1,6 @@
-const {URL} = require('url');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 /**
  * Removes the directory in the root url from the relative path
  *
@@ -12,25 +13,20 @@ const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path = '',
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-
     let parsedRoot;
-
     try {
-        parsedRoot = new URL(rootUrl);
-    } catch (e) {
+        parsedRoot = new url_1.URL(rootUrl);
+    }
+    catch (e) {
         return path;
     }
-
     // do nothing if rootUrl does not have a subdirectory
     if (parsedRoot.pathname === '/') {
         return path;
     }
-
     if (path.startsWith(parsedRoot.pathname)) {
         return path.replace(parsedRoot.pathname, '/');
     }
-
     return path;
 };
-
-module.exports = stripSubdirectoryFromPath;
+exports.default = stripSubdirectoryFromPath;

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

@@ -0,0 +1,5 @@
+import type { AbsoluteToTransformReadyOptionsInput } from './absolute-to-transform-ready';
+import { type RelativeToAbsoluteOptionsInput } from './relative-to-absolute';
+export type ToTransformReadyOptions = RelativeToAbsoluteOptionsInput & AbsoluteToTransformReadyOptionsInput;
+declare function toTransformReady(url: string, siteUrl: string, itemPath: string | null | ToTransformReadyOptions, options?: ToTransformReadyOptions): string;
+export default toTransformReady;

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

@@ -1,13 +1,21 @@
-const relativeToAbsolute = require('./relative-to-absolute');
-const absoluteToTransformReady = require('./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 relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
 function toTransformReady(url, 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 absoluteUrl = relativeToAbsolute(url, siteUrl, itemPath, options);
-    return absoluteToTransformReady(absoluteUrl, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const absoluteUrl = (0, relative_to_absolute_1.default)(url, siteUrl, finalItemPath, finalOptions);
+    return (0, absolute_to_transform_ready_1.default)(absoluteUrl, siteUrl, finalOptions);
 }
-
-module.exports = toTransformReady;
+exports.default = toTransformReady;

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

@@ -0,0 +1,9 @@
+import type { TransformReadyReplacementOptions, BaseUrlOptions } from './types';
+export interface TransformReadyToAbsoluteOptions extends TransformReadyReplacementOptions, BaseUrlOptions {
+    staticImageUrlPrefix: string;
+    staticFilesUrlPrefix: string;
+    staticMediaUrlPrefix: string;
+}
+export type TransformReadyToAbsoluteOptionsInput = Partial<TransformReadyToAbsoluteOptions>;
+declare const transformReadyToAbsolute: (str: string | undefined, root: string, _options?: TransformReadyToAbsoluteOptionsInput) => string;
+export default transformReadyToAbsolute;