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

package/lib/utils/lexical-transform.js

@@ -1,77 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const _ = require('lodash');
-
-// options.transformMap = {
-//     relativeToAbsolute: {
-//         url: (url, siteUrl, itemPath, options) => 'transformedUrl',
-//         html: (html, siteUrl, itemPath, options) => 'transformedHtml',
-//     }
-// }
-// options.transformType = 'relativeToAbsolute'
-
 function lexicalTransform(serializedLexical, siteUrl, transformFunction, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, nodes: [], transformMap: {}};
-    const options = Object.assign({}, defaultOptions, _options, {siteUrl, itemPath});
-
+    const defaultOptions = { assetsOnly: false, secure: false, nodes: [], transformMap: {} };
+    const options = Object.assign({}, defaultOptions, _options, { siteUrl, itemPath });
     if (!serializedLexical) {
         return serializedLexical;
     }
-
     // function only accepts serialized lexical so there's no chance of accidentally
     // modifying pass-by-reference objects
     const lexical = JSON.parse(serializedLexical);
-
     if (!lexical?.root?.children) {
         return serializedLexical;
     }
-
     // create a map of node types to urlTransformMap objects
     // e.g. {'image': {src: 'url', caption: 'html'}
     const nodeMap = new Map();
     options.nodes.forEach(node => node.urlTransformMap && nodeMap.set(node.getType(), node.urlTransformMap));
-
     const transformProperty = function (obj, propertyPath, transform) {
         const propertyValue = _.get(obj, propertyPath);
-
         if (Array.isArray(propertyValue)) {
             propertyValue.forEach((item) => {
                 // arrays of objects need to be defined as a nested object in the urlTransformMap
                 // so the `transform` value is that nested object
-                Object.entries(transform).forEach(([itemPropertyPath, itemTransform]) => {
-                    transformProperty(item, itemPropertyPath, itemTransform);
-                });
+                if (typeof transform === 'object') {
+                    Object.entries(transform).forEach(([itemPropertyPath, itemTransform]) => {
+                        transformProperty(item, itemPropertyPath, itemTransform);
+                    });
+                }
             });
-
             return;
         }
-
-        if (propertyValue) {
-            _.set(obj, propertyPath, options.transformMap[options.transformType][transform](propertyValue));
+        if (propertyValue && typeof transform === 'string') {
+            const transformType = options.transformType;
+            const transformRegistry = options.transformMap[transformType];
+            if (transformRegistry && transformRegistry[transform]) {
+                _.set(obj, propertyPath, transformRegistry[transform](propertyValue));
+            }
         }
     };
-
     // recursively walk the Lexical node tree transforming any card data properties and links
     const transformChildren = function (children) {
         for (const child of children) {
             const isCard = child.type && nodeMap.has(child.type);
             const isLink = !!child.url;
-
-            if (isCard) {
-                Object.entries(nodeMap.get(child.type)).forEach(([propertyPath, transform]) => {
-                    transformProperty(child, propertyPath, transform);
-                });
-            } else if (isLink) {
+            if (isCard && child.type) {
+                const urlTransformMap = nodeMap.get(child.type);
+                if (urlTransformMap) {
+                    Object.entries(urlTransformMap).forEach(([propertyPath, transform]) => {
+                        transformProperty(child, propertyPath, transform);
+                    });
+                }
+            }
+            else if (isLink && child.url) {
                 child.url = transformFunction(child.url, siteUrl, itemPath, options);
             }
-
             if (child.children) {
                 transformChildren(child.children);
             }
         }
     };
-
     transformChildren(lexical.root.children);
-
     return JSON.stringify(lexical);
 }
-
-module.exports = lexicalTransform;
+exports.default = lexicalTransform;

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

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

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

@@ -1,25 +1,25 @@
-const markdownTransform = require('./markdown-transform');
-const absoluteToRelative = require('./absolute-to-relative');
-const htmlAbsoluteToRelative = require('./html-absolute-to-relative');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const markdown_transform_1 = __importDefault(require("./markdown-transform"));
+const absolute_to_relative_1 = __importDefault(require("./absolute-to-relative"));
+const html_absolute_to_relative_1 = __importDefault(require("./html-absolute-to-relative"));
 function markdownAbsoluteToRelative(markdown = '', siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options);
-
     options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
     options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
-
     // need to ignore itemPath because absoluteToRelative functions doen't take that option
     const transformFunctions = {
         html(_url, _siteUrl, _itemPath, __options) {
-            return htmlAbsoluteToRelative(_url, _siteUrl, __options);
+            return (0, html_absolute_to_relative_1.default)(_url, _siteUrl, __options);
         },
         url(_url, _siteUrl, _itemPath, __options) {
-            return absoluteToRelative(_url, _siteUrl, __options);
+            return (0, absolute_to_relative_1.default)(_url, _siteUrl, __options);
         }
     };
-
-    return markdownTransform(markdown, siteUrl, transformFunctions, '', options);
+    return (0, markdown_transform_1.default)(markdown, siteUrl, transformFunctions, '', options);
 }
-
-module.exports = markdownAbsoluteToRelative;
+exports.default = markdownAbsoluteToRelative;

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

@@ -0,0 +1,3 @@
+import type { AbsoluteToTransformReadyOptionsInput } from './types';
+declare function markdownAbsoluteToTransformReady(markdown: string | undefined, siteUrl: string, _options?: AbsoluteToTransformReadyOptionsInput): string;
+export default markdownAbsoluteToTransformReady;

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

@@ -1,25 +1,29 @@
-const markdownTransform = require('./markdown-transform');
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-const htmlAbsoluteToTransformReady = require('./html-absolute-to-transform-ready');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const markdown_transform_1 = __importDefault(require("./markdown-transform"));
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
+const html_absolute_to_transform_ready_1 = __importDefault(require("./html-absolute-to-transform-ready"));
+const build_early_exit_match_1 = __importDefault(require("./build-early-exit-match"));
+const { buildEarlyExitMatch } = build_early_exit_match_1.default;
 function markdownAbsoluteToTransformReady(markdown = '', siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options);
-
-    options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
-    options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
-
+    const earlyExitMatch = buildEarlyExitMatch(siteUrl, options);
+    if (earlyExitMatch) {
+        options.earlyExitMatchStr = earlyExitMatch;
+    }
     // need to ignore itemPath because absoluteToTransformReady functions doen't take that option
     const transformFunctions = {
         html(_url, _siteUrl, _itemPath, __options) {
-            return htmlAbsoluteToTransformReady(_url, _siteUrl, __options);
+            return (0, html_absolute_to_transform_ready_1.default)(_url, _siteUrl, __options);
         },
         url(_url, _siteUrl, _itemPath, __options) {
-            return absoluteToTransformReady(_url, _siteUrl, __options);
+            return (0, absolute_to_transform_ready_1.default)(_url, _siteUrl, __options);
         }
     };
-
-    return markdownTransform(markdown, siteUrl, transformFunctions, '', options);
+    return (0, markdown_transform_1.default)(markdown, siteUrl, transformFunctions, '', options);
 }
-
-module.exports = markdownAbsoluteToTransformReady;
+exports.default = markdownAbsoluteToTransformReady;

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

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

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

@@ -1,22 +1,22 @@
-const markdownTransform = require('./markdown-transform');
-const htmlRelativeToAbsolute = require('./html-relative-to-absolute');
-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 markdown_transform_1 = __importDefault(require("./markdown-transform"));
+const html_relative_to_absolute_1 = __importDefault(require("./html-relative-to-absolute"));
+const relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
 function markdownRelativeToAbsolute(markdown = '', siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false};
+    const defaultOptions = { assetsOnly: false };
     const options = Object.assign({}, defaultOptions, _options);
-
     options.earlyExitMatchStr = '\\]\\([^\\s\\)]|href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
     const transformFunctions = {
-        html: htmlRelativeToAbsolute,
-        url: relativeToAbsolute
+        html: html_relative_to_absolute_1.default,
+        url: relative_to_absolute_1.default
     };
-
-    return markdownTransform(markdown, siteUrl, transformFunctions, itemPath, options);
+    return (0, markdown_transform_1.default)(markdown, siteUrl, transformFunctions, itemPath, options);
 }
-
-module.exports = markdownRelativeToAbsolute;
+exports.default = markdownRelativeToAbsolute;

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

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

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

@@ -1,22 +1,22 @@
-const markdownTransform = require('./markdown-transform');
-const htmlRelativeToTransformReady = require('./html-relative-to-transform-ready');
-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 markdown_transform_1 = __importDefault(require("./markdown-transform"));
+const html_relative_to_transform_ready_1 = __importDefault(require("./html-relative-to-transform-ready"));
+const relative_to_transform_ready_1 = __importDefault(require("./relative-to-transform-ready"));
 function markdownRelativeToTransformReady(markdown = '', siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false};
+    const defaultOptions = { assetsOnly: false };
     const options = Object.assign({}, defaultOptions, _options);
-
     options.earlyExitMatchStr = '\\]\\([^\\s\\)]|href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
     const transformFunctions = {
-        html: htmlRelativeToTransformReady,
-        url: relativeToTransformReady
+        html: html_relative_to_transform_ready_1.default,
+        url: relative_to_transform_ready_1.default
     };
-
-    return markdownTransform(markdown, siteUrl, transformFunctions, itemPath, options);
+    return (0, markdown_transform_1.default)(markdown, siteUrl, transformFunctions, itemPath, options);
 }
-
-module.exports = markdownRelativeToTransformReady;
+exports.default = markdownRelativeToTransformReady;

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

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

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

@@ -1,13 +1,21 @@
-const markdownRelativeToAbsolute = require('./markdown-relative-to-absolute');
-const markdownAbsoluteToTransformReady = require('./markdown-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 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

@@ -0,0 +1,3 @@
+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,44 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 let remark;
 const footnotes = require('remark-footnotes');
 const visit = require('unist-util-visit');
-
 function replaceLast(find, replace, str) {
     const lastIndex = str.lastIndexOf(find);
-
     if (lastIndex === -1) {
         return str;
     }
-
     const begin = str.substring(0, lastIndex);
     const end = str.substring(lastIndex + find.length);
-
     return begin + replace + end;
 }
-
 function markdownTransform(markdown = '', siteUrl, transformFunctions, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options);
-
     if (!markdown || (options.earlyExitMatchStr && !markdown.match(new RegExp(options.earlyExitMatchStr)))) {
         return markdown;
     }
-
     const replacements = [];
-
     if (!remark) {
         remark = require('remark');
     }
-
+    if (!remark) {
+        return markdown;
+    }
     const tree = remark()
-        .use({settings: {commonmark: true}})
-        .use(footnotes, {inlineNotes: true})
+        .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,
@@ -48,11 +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,
@@ -63,36 +55,29 @@ function markdownTransform(markdown = '', siteUrl, transformFunctions, itemPath,
             }
         }
     });
-
     let result = markdown;
     let offsetAdjustment = 0;
     let nestedAdjustment = 0;
-
     replacements.forEach((replacement, i) => {
         const original = markdown.slice(replacement.start, replacement.end);
         // only transform last occurrence of the old string because markdown links and images
         // have urls at the end and we see replacements for outermost nested nodes first
         const transformed = replaceLast(replacement.old, replacement.new, original);
-
         let before = result.slice(0, replacement.start + offsetAdjustment);
         let after = result.slice(replacement.end + offsetAdjustment, result.length);
-
         result = before + transformed + after;
-
         // adjust offset according to new lengths
         const nextReplacement = replacements[i + 1];
         const adjustment = transformed.length - original.length;
-
         if (nextReplacement && nextReplacement.start < replacement.end) {
             // next replacement is nested, do not apply any offset adjustments until we're out of nesting
             nestedAdjustment = nestedAdjustment + adjustment;
-        } else {
+        }
+        else {
             offsetAdjustment = offsetAdjustment + adjustment + nestedAdjustment;
             nestedAdjustment = 0;
         }
     });
-
     return result;
 }
-
-module.exports = markdownTransform;
+exports.default = markdownTransform;

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

@@ -0,0 +1,3 @@
+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,16 +1,17 @@
-const absoluteToRelative = require('./absolute-to-relative');
-const mobiledocTransform = require('./mobiledoc-transform');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const absolute_to_relative_1 = __importDefault(require("./absolute-to-relative"));
+const 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 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

@@ -0,0 +1,3 @@
+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,16 +1,17 @@
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-const mobiledocTransform = require('./mobiledoc-transform');
-
-function mobiledocAbsoluteToRelative(serializedMobiledoc, siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
-    const overrideOptions = {siteUrl, transformType: 'toTransformReady'};
+"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 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

@@ -0,0 +1,3 @@
+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,12 +1,14 @@
-const relativeToAbsolute = require('./relative-to-absolute');
-const mobiledocTransform = require('./mobiledoc-transform');
-
+"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 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 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

@@ -0,0 +1,3 @@
+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,12 +1,14 @@
-const relativeToTransformReady = require('./relative-to-transform-ready');
-const mobiledocTransform = require('./mobiledoc-transform');
-
+"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 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 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

@@ -0,0 +1,3 @@
+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 @@
-const mobiledocRelativeToAbsolute = require('./mobiledoc-relative-to-absolute');
-const mobiledocAbsoluteToTransformReady = require('./mobiledoc-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 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

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