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

package/lib/utils/html-transform.js

@@ -1,63 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cheerio = require('cheerio');
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-
 function extractSrcsetUrls(srcset = '') {
     return srcset.split(',').map((part) => {
         return part.trim().split(/\s+/)[0];
     });
 }
-
 function extractStyleUrls(style = '') {
     const urls = [];
     const regex = /url\(['|"]([^)]+)['|"]\)/g;
     let match;
-
     while ((match = regex.exec(style)) !== null) {
         urls.push(match[1]);
     }
-
     return urls;
 }
-
-function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options) {
-    const defaultOptions = {assetsOnly: false, secure: false};
+function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options = {}) {
+    const defaultOptions = {
+        assetsOnly: false,
+        secure: false
+    };
     const options = Object.assign({}, defaultOptions, _options || {});
-
     if (!html || (options.earlyExitMatchStr && !html.match(new RegExp(options.earlyExitMatchStr)))) {
         return html;
     }
-
-    const cheerio = require('cheerio');
-    const htmlContent = cheerio.load(html, {decodeEntities: false});
-
-    // replacements is keyed with the attr name + original relative value so
-    // that we can implement skips for untouchable urls
-    //
-    // replacements = {
-    //     'href="/test"': [
-    //         {name: 'href', originalValue: '/test', absoluteValue: '.../test'},
-    //         {name: 'href', originalValue: '/test', skip: true}, // found inside a <code> element
-    //         {name: 'href', originalValue: '/test', absoluteValue: '.../test'},
-    //     ]
-    // }
+    const htmlContent = cheerio.load(html, { decodeEntities: false });
     const replacements = {};
-
     function addReplacement(replacement) {
         const key = `${replacement.name}="${replacement.originalValue}"`;
-
         if (!replacements[key]) {
             replacements[key] = [];
         }
-
         replacements[key].push(replacement);
     }
-
     // find all of the relative url attributes that we care about
     ['href', 'src', 'srcset', 'style'].forEach((attributeName) => {
         htmlContent('[' + attributeName + ']').each((ix, el) => {
             // ignore <stream> elems and html inside of <code> elements
-            if (el.name === 'stream' || htmlContent(el).closest('code').length) {
+            const elementName = 'name' in el ? el.name : null;
+            if (elementName === 'stream' || htmlContent(el).closest('code').length) {
                 addReplacement({
                     name: attributeName,
                     originalValue: htmlContent(el).attr(attributeName),
@@ -65,28 +49,24 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
                 });
                 return;
             }
-
-            el = htmlContent(el);
-            const originalValue = el.attr(attributeName);
-
+            const elWrapper = htmlContent(el);
+            const originalValue = elWrapper.attr(attributeName);
             if (attributeName === 'srcset' || attributeName === 'style') {
                 let urls;
-
                 if (attributeName === 'srcset') {
                     urls = extractSrcsetUrls(originalValue);
-                } else {
+                }
+                else {
                     urls = extractStyleUrls(originalValue);
                 }
-                const absoluteUrls = urls.map(url => transformFunction(url, siteUrl, itemPath, options));
+                const absoluteUrls = urls.map((url) => transformFunction(url, siteUrl, itemPath, options));
                 let transformedValue = originalValue;
-
                 urls.forEach((url, i) => {
                     if (absoluteUrls[i]) {
-                        let regex = new RegExp(escapeRegExp(url), 'g');
+                        const regex = new RegExp(escapeRegExp(url), 'g');
                         transformedValue = transformedValue.replace(regex, absoluteUrls[i]);
                     }
                 });
-
                 if (transformedValue !== originalValue) {
                     addReplacement({
                         name: attributeName,
@@ -94,9 +74,9 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
                         transformedValue
                     });
                 }
-            } else {
+            }
+            else {
                 const transformedValue = transformFunction(originalValue, siteUrl, itemPath, options);
-
                 if (transformedValue !== originalValue) {
                     addReplacement({
                         name: attributeName,
@@ -107,24 +87,25 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
             }
         });
     });
-
     // Loop over all replacements and use a regex to replace urls in the original html string.
     // Allows indentation and formatting to be kept compared to using DOM manipulation and render
     for (const [, attrs] of Object.entries(replacements)) {
         let skipCount = 0;
-
-        attrs.forEach(({skip, name, originalValue, transformedValue}) => {
+        attrs.forEach(({ skip, name, originalValue, transformedValue }) => {
             if (skip) {
                 skipCount += 1;
                 return;
             }
-
+            // transformedValue is guaranteed to exist here because we only add replacements
+            // when transformedValue !== originalValue, and we've already skipped entries with skip: true
+            if (!transformedValue) {
+                return;
+            }
             // this regex avoids matching unrelated plain text by checking that the attribute/value pair
             // is surrounded by <> - that should be sufficient because if the plain text had that wrapper
             // it would be parsed as a tag
             // eslint-disable-next-line no-useless-escape
             const regex = new RegExp(`<[a-zA-Z][^>]*?(${name}=['"](${escapeRegExp(originalValue)})['"]).*?>`, 'gs');
-
             let matchCount = 0;
             html = html.replace(regex, (match, p1) => {
                 let result = match;
@@ -136,8 +117,6 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
             });
         });
     }
-
     return html;
 }
-
-module.exports = htmlTransform;
+exports.default = htmlTransform;

package/lib/utils/index.d.ts

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

package/lib/utils/index.js

@@ -1,38 +1,117 @@
-module.exports = {
-    absoluteToRelative: require('./absolute-to-relative'),
-    absoluteToTransformReady: require('./absolute-to-transform-ready'),
-    deduplicateDoubleSlashes: require('./deduplicate-double-slashes'),
-    deduplicateSubdirectory: require('./deduplicate-subdirectory'),
-    htmlAbsoluteToRelative: require('./html-absolute-to-relative'),
-    htmlRelativeToAbsolute: require('./html-relative-to-absolute'),
-    htmlAbsoluteToTransformReady: require('./html-absolute-to-transform-ready'),
-    htmlRelativeToTransformReady: require('./html-relative-to-transform-ready'),
-    htmlToTransformReady: require('./html-to-transform-ready'),
-    isSSL: require('./is-ssl'),
-    markdownAbsoluteToRelative: require('./markdown-absolute-to-relative'),
-    markdownRelativeToAbsolute: require('./markdown-relative-to-absolute'),
-    markdownAbsoluteToTransformReady: require('./markdown-absolute-to-transform-ready'),
-    markdownRelativeToTransformReady: require('./markdown-relative-to-transform-ready'),
-    markdownToTransformReady: require('./markdown-to-transform-ready'),
-    mobiledocAbsoluteToRelative: require('./mobiledoc-absolute-to-relative'),
-    mobiledocRelativeToAbsolute: require('./mobiledoc-relative-to-absolute'),
-    mobiledocAbsoluteToTransformReady: require('./mobiledoc-absolute-to-transform-ready'),
-    mobiledocRelativeToTransformReady: require('./mobiledoc-relative-to-transform-ready'),
-    mobiledocToTransformReady: require('./mobiledoc-to-transform-ready'),
-    lexicalAbsoluteToRelative: require('./lexical-absolute-to-relative'),
-    lexicalRelativeToAbsolute: require('./lexical-relative-to-absolute'),
-    lexicalAbsoluteToTransformReady: require('./lexical-absolute-to-transform-ready'),
-    lexicalRelativeToTransformReady: require('./lexical-relative-to-transform-ready'),
-    lexicalToTransformReady: require('./lexical-to-transform-ready'),
-    plaintextAbsoluteToTransformReady: require('./plaintext-absolute-to-transform-ready'),
-    plaintextRelativeToTransformReady: require('./plaintext-relative-to-transform-ready'),
-    plaintextToTransformReady: require('./plaintext-to-transform-ready'),
-    relativeToAbsolute: require('./relative-to-absolute'),
-    relativeToTransformReady: require('./relative-to-transform-ready'),
-    replacePermalink: require('./replace-permalink'),
-    stripSubdirectoryFromPath: require('./strip-subdirectory-from-path'),
-    toTransformReady: require('./to-transform-ready'),
-    transformReadyToAbsolute: require('./transform-ready-to-absolute'),
-    transformReadyToRelative: require('./transform-ready-to-relative'),
-    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 });
+exports.urlJoin = exports.transformReadyToRelative = exports.transformReadyToAbsolute = exports.toTransformReady = exports.stripSubdirectoryFromPath = exports.replacePermalink = exports.relativeToTransformReady = exports.relativeToAbsolute = exports.plaintextToTransformReady = exports.plaintextRelativeToTransformReady = exports.plaintextAbsoluteToTransformReady = exports.mobiledocToTransformReady = exports.mobiledocRelativeToTransformReady = exports.mobiledocAbsoluteToTransformReady = exports.mobiledocRelativeToAbsolute = exports.mobiledocAbsoluteToRelative = exports.markdownToTransformReady = exports.markdownRelativeToTransformReady = exports.markdownAbsoluteToTransformReady = exports.markdownRelativeToAbsolute = exports.markdownAbsoluteToRelative = exports.lexicalToTransformReady = exports.lexicalRelativeToTransformReady = exports.lexicalRelativeToAbsolute = exports.lexicalAbsoluteToTransformReady = exports.lexicalAbsoluteToRelative = exports.isSSL = exports.htmlToTransformReady = exports.htmlRelativeToTransformReady = exports.htmlAbsoluteToTransformReady = exports.htmlRelativeToAbsolute = exports.htmlAbsoluteToRelative = exports.deduplicateSubdirectory = exports.deduplicateDoubleSlashes = exports.absoluteToTransformReady = exports.absoluteToRelative = void 0;
+const absolute_to_relative_1 = __importDefault(require("./absolute-to-relative"));
+exports.absoluteToRelative = absolute_to_relative_1.default;
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
+exports.absoluteToTransformReady = absolute_to_transform_ready_1.default;
+const deduplicate_double_slashes_1 = __importDefault(require("./deduplicate-double-slashes"));
+exports.deduplicateDoubleSlashes = deduplicate_double_slashes_1.default;
+const deduplicate_subdirectory_1 = __importDefault(require("./deduplicate-subdirectory"));
+exports.deduplicateSubdirectory = deduplicate_subdirectory_1.default;
+const html_absolute_to_relative_1 = __importDefault(require("./html-absolute-to-relative"));
+exports.htmlAbsoluteToRelative = html_absolute_to_relative_1.default;
+const html_absolute_to_transform_ready_1 = __importDefault(require("./html-absolute-to-transform-ready"));
+exports.htmlAbsoluteToTransformReady = html_absolute_to_transform_ready_1.default;
+const html_relative_to_absolute_1 = __importDefault(require("./html-relative-to-absolute"));
+exports.htmlRelativeToAbsolute = html_relative_to_absolute_1.default;
+const html_relative_to_transform_ready_1 = __importDefault(require("./html-relative-to-transform-ready"));
+exports.htmlRelativeToTransformReady = html_relative_to_transform_ready_1.default;
+const html_to_transform_ready_1 = __importDefault(require("./html-to-transform-ready"));
+exports.htmlToTransformReady = html_to_transform_ready_1.default;
+const is_ssl_1 = __importDefault(require("./is-ssl"));
+exports.isSSL = is_ssl_1.default;
+const lexical_absolute_to_relative_1 = __importDefault(require("./lexical-absolute-to-relative"));
+exports.lexicalAbsoluteToRelative = lexical_absolute_to_relative_1.default;
+const lexical_absolute_to_transform_ready_1 = __importDefault(require("./lexical-absolute-to-transform-ready"));
+exports.lexicalAbsoluteToTransformReady = lexical_absolute_to_transform_ready_1.default;
+const lexical_relative_to_absolute_1 = __importDefault(require("./lexical-relative-to-absolute"));
+exports.lexicalRelativeToAbsolute = lexical_relative_to_absolute_1.default;
+const lexical_relative_to_transform_ready_1 = __importDefault(require("./lexical-relative-to-transform-ready"));
+exports.lexicalRelativeToTransformReady = lexical_relative_to_transform_ready_1.default;
+const lexical_to_transform_ready_1 = __importDefault(require("./lexical-to-transform-ready"));
+exports.lexicalToTransformReady = lexical_to_transform_ready_1.default;
+const markdown_absolute_to_relative_1 = __importDefault(require("./markdown-absolute-to-relative"));
+exports.markdownAbsoluteToRelative = markdown_absolute_to_relative_1.default;
+const markdown_relative_to_absolute_1 = __importDefault(require("./markdown-relative-to-absolute"));
+exports.markdownRelativeToAbsolute = markdown_relative_to_absolute_1.default;
+const markdown_absolute_to_transform_ready_1 = __importDefault(require("./markdown-absolute-to-transform-ready"));
+exports.markdownAbsoluteToTransformReady = markdown_absolute_to_transform_ready_1.default;
+const markdown_relative_to_transform_ready_1 = __importDefault(require("./markdown-relative-to-transform-ready"));
+exports.markdownRelativeToTransformReady = markdown_relative_to_transform_ready_1.default;
+const markdown_to_transform_ready_1 = __importDefault(require("./markdown-to-transform-ready"));
+exports.markdownToTransformReady = markdown_to_transform_ready_1.default;
+const mobiledoc_absolute_to_relative_1 = __importDefault(require("./mobiledoc-absolute-to-relative"));
+exports.mobiledocAbsoluteToRelative = mobiledoc_absolute_to_relative_1.default;
+const mobiledoc_relative_to_absolute_1 = __importDefault(require("./mobiledoc-relative-to-absolute"));
+exports.mobiledocRelativeToAbsolute = mobiledoc_relative_to_absolute_1.default;
+const mobiledoc_absolute_to_transform_ready_1 = __importDefault(require("./mobiledoc-absolute-to-transform-ready"));
+exports.mobiledocAbsoluteToTransformReady = mobiledoc_absolute_to_transform_ready_1.default;
+const mobiledoc_relative_to_transform_ready_1 = __importDefault(require("./mobiledoc-relative-to-transform-ready"));
+exports.mobiledocRelativeToTransformReady = mobiledoc_relative_to_transform_ready_1.default;
+const mobiledoc_to_transform_ready_1 = __importDefault(require("./mobiledoc-to-transform-ready"));
+exports.mobiledocToTransformReady = mobiledoc_to_transform_ready_1.default;
+const plaintext_absolute_to_transform_ready_1 = __importDefault(require("./plaintext-absolute-to-transform-ready"));
+exports.plaintextAbsoluteToTransformReady = plaintext_absolute_to_transform_ready_1.default;
+const plaintext_relative_to_transform_ready_1 = __importDefault(require("./plaintext-relative-to-transform-ready"));
+exports.plaintextRelativeToTransformReady = plaintext_relative_to_transform_ready_1.default;
+const plaintext_to_transform_ready_1 = __importDefault(require("./plaintext-to-transform-ready"));
+exports.plaintextToTransformReady = plaintext_to_transform_ready_1.default;
+const relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+exports.relativeToAbsolute = relative_to_absolute_1.default;
+const relative_to_transform_ready_1 = __importDefault(require("./relative-to-transform-ready"));
+exports.relativeToTransformReady = relative_to_transform_ready_1.default;
+const replace_permalink_1 = __importDefault(require("./replace-permalink"));
+exports.replacePermalink = replace_permalink_1.default;
+const strip_subdirectory_from_path_1 = __importDefault(require("./strip-subdirectory-from-path"));
+exports.stripSubdirectoryFromPath = strip_subdirectory_from_path_1.default;
+const to_transform_ready_1 = __importDefault(require("./to-transform-ready"));
+exports.toTransformReady = to_transform_ready_1.default;
+const transform_ready_to_absolute_1 = __importDefault(require("./transform-ready-to-absolute"));
+exports.transformReadyToAbsolute = transform_ready_to_absolute_1.default;
+const transform_ready_to_relative_1 = __importDefault(require("./transform-ready-to-relative"));
+exports.transformReadyToRelative = transform_ready_to_relative_1.default;
+const url_join_1 = __importDefault(require("./url-join"));
+exports.urlJoin = url_join_1.default;
+const utils = {
+    absoluteToRelative: absolute_to_relative_1.default,
+    absoluteToTransformReady: absolute_to_transform_ready_1.default,
+    deduplicateDoubleSlashes: deduplicate_double_slashes_1.default,
+    deduplicateSubdirectory: deduplicate_subdirectory_1.default,
+    htmlAbsoluteToRelative: html_absolute_to_relative_1.default,
+    htmlRelativeToAbsolute: html_relative_to_absolute_1.default,
+    htmlAbsoluteToTransformReady: html_absolute_to_transform_ready_1.default,
+    htmlRelativeToTransformReady: html_relative_to_transform_ready_1.default,
+    htmlToTransformReady: html_to_transform_ready_1.default,
+    isSSL: is_ssl_1.default,
+    lexicalAbsoluteToRelative: lexical_absolute_to_relative_1.default,
+    lexicalRelativeToAbsolute: lexical_relative_to_absolute_1.default,
+    lexicalAbsoluteToTransformReady: lexical_absolute_to_transform_ready_1.default,
+    lexicalRelativeToTransformReady: lexical_relative_to_transform_ready_1.default,
+    lexicalToTransformReady: lexical_to_transform_ready_1.default,
+    markdownAbsoluteToRelative: markdown_absolute_to_relative_1.default,
+    markdownAbsoluteToTransformReady: markdown_absolute_to_transform_ready_1.default,
+    markdownRelativeToAbsolute: markdown_relative_to_absolute_1.default,
+    markdownRelativeToTransformReady: markdown_relative_to_transform_ready_1.default,
+    markdownToTransformReady: markdown_to_transform_ready_1.default,
+    mobiledocAbsoluteToRelative: mobiledoc_absolute_to_relative_1.default,
+    mobiledocAbsoluteToTransformReady: mobiledoc_absolute_to_transform_ready_1.default,
+    mobiledocRelativeToAbsolute: mobiledoc_relative_to_absolute_1.default,
+    mobiledocRelativeToTransformReady: mobiledoc_relative_to_transform_ready_1.default,
+    mobiledocToTransformReady: mobiledoc_to_transform_ready_1.default,
+    plaintextAbsoluteToTransformReady: plaintext_absolute_to_transform_ready_1.default,
+    plaintextRelativeToTransformReady: plaintext_relative_to_transform_ready_1.default,
+    plaintextToTransformReady: plaintext_to_transform_ready_1.default,
+    relativeToAbsolute: relative_to_absolute_1.default,
+    relativeToTransformReady: relative_to_transform_ready_1.default,
+    replacePermalink: replace_permalink_1.default,
+    stripSubdirectoryFromPath: strip_subdirectory_from_path_1.default,
+    toTransformReady: to_transform_ready_1.default,
+    transformReadyToAbsolute: transform_ready_to_absolute_1.default,
+    transformReadyToRelative: transform_ready_to_relative_1.default,
+    urlJoin: url_join_1.default
+};
+exports.default = utils;

package/lib/utils/is-ssl.d.ts

@@ -0,0 +1,2 @@
+declare function isSSL(urlToParse: string): boolean;
+export default isSSL;

package/lib/utils/is-ssl.js

@@ -1,9 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 // require the whatwg compatible URL library (same behaviour in node and browser)
-const {URL} = require('url');
-
+const url_1 = require("url");
 function isSSL(urlToParse) {
-    const {protocol} = new URL(urlToParse);
+    const { protocol } = new url_1.URL(urlToParse);
     return protocol === 'https:';
 }
-
-module.exports = isSSL;
+exports.default = isSSL;

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

@@ -0,0 +1,3 @@
+import type { LexicalTransformOptionsInput } from './types';
+declare function lexicalAbsoluteToRelative(serializedLexical: string, siteUrl: string, _options?: LexicalTransformOptionsInput): string;
+export default lexicalAbsoluteToRelative;

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

@@ -1,16 +1,17 @@
-const absoluteToRelative = require('./absolute-to-relative');
-const lexicalTransform = require('./lexical-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 lexical_transform_1 = __importDefault(require("./lexical-transform"));
 function lexicalAbsoluteToRelative(serializedLexical, siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, nodes: [], transformMap: {}};
-    const overrideOptions = {siteUrl, transformType: 'absoluteToRelative'};
+    const defaultOptions = { assetsOnly: false, secure: false, nodes: [], transformMap: {} };
+    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 lexicalTransform(serializedLexical, siteUrl, transformFunction, '', options);
+    return (0, lexical_transform_1.default)(serializedLexical, siteUrl, transformFunction, '', options);
 }
-
-module.exports = lexicalAbsoluteToRelative;
+exports.default = lexicalAbsoluteToRelative;

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

@@ -0,0 +1,3 @@
+import type { LexicalTransformOptionsInput } from './types';
+declare function lexicalAbsoluteToTransformReady(serializedLexical: string, siteUrl: string, _options?: LexicalTransformOptionsInput): string;
+export default lexicalAbsoluteToTransformReady;

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

@@ -1,16 +1,17 @@
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-const lexicalTransform = require('./lexical-transform');
-
-function lexicalAbsoluteToRelative(serializedLexical, siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, nodes: [], transformMap: {}};
-    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 lexical_transform_1 = __importDefault(require("./lexical-transform"));
+function lexicalAbsoluteToTransformReady(serializedLexical, siteUrl, _options = {}) {
+    const defaultOptions = { assetsOnly: false, secure: false, nodes: [], transformMap: {} };
+    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 lexicalTransform(serializedLexical, siteUrl, transformFunction, '', options);
+    return (0, lexical_transform_1.default)(serializedLexical, siteUrl, transformFunction, '', options);
 }
-
-module.exports = lexicalAbsoluteToRelative;
+exports.default = lexicalAbsoluteToTransformReady;

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

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

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

@@ -1,12 +1,14 @@
-const relativeToAbsolute = require('./relative-to-absolute');
-const lexicalTransform = require('./lexical-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 lexical_transform_1 = __importDefault(require("./lexical-transform"));
 function lexicalRelativeToAbsolute(serializedLexical, siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, nodes: [], transformMap: {}};
-    const overrideOptions = {siteUrl, itemPath, transformType: 'relativeToAbsolute'};
+    const defaultOptions = { assetsOnly: false, secure: false, nodes: [], transformMap: {} };
+    const overrideOptions = { siteUrl, itemPath, transformType: 'relativeToAbsolute' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
-    return lexicalTransform(serializedLexical, siteUrl, relativeToAbsolute, itemPath, options);
+    return (0, lexical_transform_1.default)(serializedLexical, siteUrl, relative_to_absolute_1.default, itemPath, options);
 }
-
-module.exports = lexicalRelativeToAbsolute;
+exports.default = lexicalRelativeToAbsolute;

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

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

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

@@ -1,12 +1,14 @@
-const relativeToTransformReady = require('./relative-to-transform-ready');
-const lexicalTransform = require('./lexical-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 lexical_transform_1 = __importDefault(require("./lexical-transform"));
 function lexicalRelativeToTransformReady(serializedLexical, siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, nodes: [], transformMap: {}};
-    const overrideOptions = {siteUrl, transformType: 'toTransformReady'};
+    const defaultOptions = { assetsOnly: false, secure: false, nodes: [], transformMap: {} };
+    const overrideOptions = { siteUrl, transformType: 'toTransformReady' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
-    return lexicalTransform(serializedLexical, siteUrl, relativeToTransformReady, itemPath, options);
+    return (0, lexical_transform_1.default)(serializedLexical, siteUrl, relative_to_transform_ready_1.default, itemPath, options);
 }
-
-module.exports = lexicalRelativeToTransformReady;
+exports.default = lexicalRelativeToTransformReady;

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

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

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

@@ -1,13 +1,21 @@
-const lexicalRelativeToAbsolute = require('./lexical-relative-to-absolute');
-const lexicalAbsoluteToTransformReady = require('./lexical-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 lexical_relative_to_absolute_1 = __importDefault(require("./lexical-relative-to-absolute"));
+const lexical_absolute_to_transform_ready_1 = __importDefault(require("./lexical-absolute-to-transform-ready"));
 function lexicalToTransformReady(lexical, 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 = lexicalRelativeToAbsolute(lexical, siteUrl, itemPath, options);
-    return lexicalAbsoluteToTransformReady(absolute, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const absolute = (0, lexical_relative_to_absolute_1.default)(lexical, siteUrl, finalItemPath, finalOptions);
+    return (0, lexical_absolute_to_transform_ready_1.default)(absolute, siteUrl, finalOptions);
 }
-
-module.exports = lexicalToTransformReady;
+exports.default = lexicalToTransformReady;

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

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