@tryghost/url-utils 5.0.0 → 5.1.1

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

@@ -1,8 +1,11 @@
 "use strict";
-// @ts-nocheck
-const markdownTransform = require('./markdown-transform');
-const htmlRelativeToAbsolute = require('./html-relative-to-absolute');
-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 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 options = Object.assign({}, defaultOptions, _options);
@@ -11,9 +14,9 @@ function markdownRelativeToAbsolute(markdown = '', siteUrl, itemPath, _options =
         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

@@ -1,4 +1,3 @@
-declare const markdownTransform: any;
-declare const htmlRelativeToTransformReady: any;
-declare const relativeToTransformReady: any;
-declare function markdownRelativeToTransformReady(markdown: string | undefined, siteUrl: any, itemPath: any, _options?: {}): any;
+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,8 +1,11 @@
 "use strict";
-// @ts-nocheck
-const markdownTransform = require('./markdown-transform');
-const htmlRelativeToTransformReady = require('./html-relative-to-transform-ready');
-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 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 options = Object.assign({}, defaultOptions, _options);
@@ -11,9 +14,9 @@ function markdownRelativeToTransformReady(markdown = '', siteUrl, itemPath, _opt
         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

@@ -1,3 +1,3 @@
-declare const markdownRelativeToAbsolute: any;
-declare const markdownAbsoluteToTransformReady: any;
-declare function markdownToTransformReady(markdown: any, siteUrl: any, itemPath: any, options: any): any;
+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 @@
 "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,8 +1,10 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-require-imports */
 let remark;
 const footnotes = require('remark-footnotes');
 const visit = require('unist-util-visit');
+/* eslint-enable @typescript-eslint/no-require-imports */
 function replaceLast(find, replace, str) {
     const lastIndex = str.lastIndexOf(find);
     if (lastIndex === -1) {
@@ -20,16 +22,20 @@ function markdownTransform(markdown = '', siteUrl, transformFunctions, itemPath,
     }
     const replacements = [];
     if (!remark) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
         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 +45,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 +83,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;