@tryghost/url-utils 5.0.0-rc.0 → 5.0.0

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

@@ -1,69 +1,18 @@
-const {URL} = require('url');
+"use strict";
+// @ts-nocheck
+const { URL } = require('url');
 const absoluteToRelative = require('./absolute-to-relative');
-
-function normalizeBaseUrl(baseUrl) {
-    if (!baseUrl) {
-        return null;
-    }
-
+function isRelative(url) {
+    let parsedInput;
     try {
-        const parsed = new URL(baseUrl);
-        let pathname = parsed.pathname.replace(/\/$/, '');
-        if (pathname === '/') {
-            pathname = '';
-        }
-
-        return {
-            origin: parsed.origin,
-            pathname
-        };
-    } catch (e) {
-        return null;
+        parsedInput = new URL(url, 'http://relative');
     }
-}
-
-function matchCdnBase(parsedUrl, options) {
-    const candidates = [
-        {base: normalizeBaseUrl(options.mediaBaseUrl), prefix: options.staticMediaUrlPrefix},
-        {base: normalizeBaseUrl(options.filesBaseUrl), prefix: options.staticFilesUrlPrefix}
-    ];
-
-    for (const candidate of candidates) {
-        if (!candidate.base || !candidate.prefix) {
-            continue;
-        }
-
-        if (parsedUrl.origin !== candidate.base.origin) {
-            continue;
-        }
-
-        let pathname = parsedUrl.pathname;
-        const basePath = candidate.base.pathname;
-
-        if (basePath) {
-            if (pathname === basePath) {
-                pathname = '/';
-            } else if (pathname.startsWith(basePath + '/')) {
-                pathname = pathname.slice(basePath.length);
-            } else {
-                continue;
-            }
-        }
-
-        if (!pathname.startsWith('/')) {
-            pathname = `/${pathname}`;
-        }
-
-        if (!pathname.startsWith(`/${candidate.prefix}`)) {
-            continue;
-        }
-
-        return `${pathname}${parsedUrl.search}${parsedUrl.hash}`;
+    catch (e) {
+        // url was unparseable
+        return false;
     }
-
-    return null;
+    return parsedInput.origin === 'http://relative';
 }
-
 const absoluteToTransformReady = function (url, root, _options = {}) {
     const defaultOptions = {
         replacementStr: '__GHOST_URL__',
@@ -76,42 +25,33 @@ const absoluteToTransformReady = function (url, root, _options = {}) {
         mediaBaseUrl: null
     };
     const options = Object.assign({}, defaultOptions, _options);
-
-    let parsedInput;
-    try {
-        parsedInput = new URL(url, 'http://relative');
-    } catch (e) {
-        // url was unparseable
+    if (isRelative(url)) {
         return url;
     }
-
-    if (parsedInput.origin !== 'http://relative') {
-        const cdnMatch = matchCdnBase(parsedInput, options);
-        if (cdnMatch) {
-            return `${options.replacementStr}${cdnMatch}`;
+    // convert to relative with stripped subdir
+    // always returns root-relative starting with forward slash
+    const rootRelativeUrl = absoluteToRelative(url, root, options);
+    if (isRelative(rootRelativeUrl)) {
+        return `${options.replacementStr}${rootRelativeUrl}`;
+    }
+    if (options.mediaBaseUrl) {
+        const mediaRelativeUrl = absoluteToRelative(url, options.mediaBaseUrl, options);
+        if (isRelative(mediaRelativeUrl)) {
+            return `${options.replacementStr}${mediaRelativeUrl}`;
         }
     }
-
-    if (parsedInput.origin === 'http://relative') {
-        return url;
+    if (options.filesBaseUrl) {
+        const filesRelativeUrl = absoluteToRelative(url, options.filesBaseUrl, options);
+        if (isRelative(filesRelativeUrl)) {
+            return `${options.replacementStr}${filesRelativeUrl}`;
+        }
     }
-
-    // convert to relative with stripped subdir
-    // always returns root-relative starting with forward slash
-    const relativeUrl = absoluteToRelative(url, root, options);
-
-    // return still absolute urls as-is (eg. external site, mailto, etc)
-    try {
-        const parsedURL = new URL(relativeUrl, 'http://relative');
-        if (parsedURL.origin !== 'http://relative') {
-            return url;
+    if (options.imageBaseUrl) {
+        const imageRelativeUrl = absoluteToRelative(url, options.imageBaseUrl, options);
+        if (isRelative(imageRelativeUrl)) {
+            return `${options.replacementStr}${imageRelativeUrl}`;
         }
-    } catch (e) {
-        // url was unparseable
-        return url;
     }
-
-    return `${options.replacementStr}${relativeUrl}`;
+    return url;
 };
-
 module.exports = absoluteToTransformReady;

package/lib/utils/build-early-exit-match.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Build a regex pattern that matches any of the configured base URLs (site URL + CDN URLs).
+ * This is used for early exit optimizations - if content doesn't contain any of these URLs,
+ * we can skip expensive parsing.
+ *
+ * @param {string} siteUrl - The site's base URL
+ * @param {Object} options - Options containing CDN base URLs
+ * @param {string} [options.imageBaseUrl] - CDN base URL for images
+ * @param {string} [options.filesBaseUrl] - CDN base URL for files
+ * @param {string} [options.mediaBaseUrl] - CDN base URL for media
+ * @param {boolean} [options.ignoreProtocol=true] - Whether to strip protocol from URLs
+ * @returns {string|null} Regex pattern matching any configured base URL, or null if none configured
+ */
+declare function buildEarlyExitMatch(siteUrl: any, options?: {}): any;

package/lib/utils/build-early-exit-match.js

@@ -0,0 +1,39 @@
+"use strict";
+// @ts-nocheck
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Build a regex pattern that matches any of the configured base URLs (site URL + CDN URLs).
+ * This is used for early exit optimizations - if content doesn't contain any of these URLs,
+ * we can skip expensive parsing.
+ *
+ * @param {string} siteUrl - The site's base URL
+ * @param {Object} options - Options containing CDN base URLs
+ * @param {string} [options.imageBaseUrl] - CDN base URL for images
+ * @param {string} [options.filesBaseUrl] - CDN base URL for files
+ * @param {string} [options.mediaBaseUrl] - CDN base URL for media
+ * @param {boolean} [options.ignoreProtocol=true] - Whether to strip protocol from URLs
+ * @returns {string|null} Regex pattern matching any configured base URL, or null if none configured
+ */
+function buildEarlyExitMatch(siteUrl, options = {}) {
+    const candidates = [siteUrl, options.imageBaseUrl, options.filesBaseUrl, options.mediaBaseUrl]
+        .filter(Boolean)
+        .map((value) => {
+        let normalized = options.ignoreProtocol ? value.replace(/http:|https:/, '') : value;
+        return normalized.replace(/\/$/, '');
+    })
+        .filter(Boolean)
+        .map(escapeRegExp);
+    if (!candidates.length) {
+        return null;
+    }
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    return `(?:${candidates.join('|')})`;
+}
+module.exports = {
+    buildEarlyExitMatch,
+    escapeRegExp
+};

package/lib/utils/deduplicate-double-slashes.d.ts

@@ -0,0 +1 @@
+declare function deduplicateDoubleSlashes(url: any): any;

package/lib/utils/deduplicate-double-slashes.js

@@ -1,5 +1,9 @@
+"use strict";
+// @ts-nocheck
 function deduplicateDoubleSlashes(url) {
-    return url.replace(/\/\//g, '/');
+    // Preserve protocol slashes (e.g., http://, https://) and only deduplicate
+    // slashes in the path portion. The pattern (^|[^:])\/\/+ matches double slashes
+    // that are either at the start of the string or not preceded by a colon.
+    return url.replace(/(^|[^:])\/\/+/g, '$1/');
 }
-
 module.exports = deduplicateDoubleSlashes;

package/lib/utils/deduplicate-subdirectory.d.ts

@@ -0,0 +1,9 @@
+declare const URL: any;
+/**
+ * Remove duplicated directories from the start of a path or url's path
+ *
+ * @param {string} url URL or pathname with possible duplicate subdirectory
+ * @param {string} rootUrl Root URL with an optional subdirectory
+ * @returns {string} URL or pathname with any duplicated subdirectory removed
+ */
+declare const deduplicateSubdirectory: (url: any, rootUrl: any) => any;

package/lib/utils/deduplicate-subdirectory.js

@@ -1,5 +1,6 @@
-const {URL} = require('url');
-
+"use strict";
+// @ts-nocheck
+const { URL } = require('url');
 /**
  * Remove duplicated directories from the start of a path or url's path
  *
@@ -12,20 +13,15 @@ const deduplicateSubdirectory = function deduplicateSubdirectory(url, rootUrl) {
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-
     const parsedRoot = new URL(rootUrl);
-
     // do nothing if rootUrl does not have a subdirectory
     if (parsedRoot.pathname === '/') {
         return url;
     }
-
     const subdir = parsedRoot.pathname.replace(/(^\/|\/$)+/g, '');
     // we can have subdirs that match TLDs so we need to restrict matches to
     // duplicates that start with a / or the beginning of the url
     const subdirRegex = new RegExp(`(^|/)${subdir}/${subdir}(/|$)`);
-
     return url.replace(subdirRegex, `$1${subdir}/`);
 };
-
 module.exports = deduplicateSubdirectory;

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

@@ -0,0 +1,3 @@
+declare const htmlTransform: any;
+declare const absoluteToRelative: any;
+declare function htmlAbsoluteToRelative(html: string | undefined, siteUrl: any, _options: any): any;

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

@@ -1,20 +1,17 @@
+"use strict";
+// @ts-nocheck
 const htmlTransform = require('./html-transform');
 const absoluteToRelative = require('./absolute-to-relative');
-
 function htmlAbsoluteToRelative(html = '', siteUrl, _options) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options || {});
-
     // exit early and avoid parsing if the content does not contain the siteUrl
     options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
     options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
-
     // need to ignore itemPath because absoluteToRelative doesn't take that option
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
         return absoluteToRelative(_url, _siteUrl, __options);
     };
-
     return htmlTransform(html, siteUrl, transformFunction, '', options);
 }
-
 module.exports = htmlAbsoluteToRelative;

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

@@ -0,0 +1,4 @@
+declare const htmlTransform: any;
+declare const absoluteToTransformReady: any;
+declare const buildEarlyExitMatch: any;
+declare const htmlAbsoluteToTransformReady: (html: string | undefined, siteUrl: any, _options: any) => any;

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

@@ -1,20 +1,17 @@
+"use strict";
+// @ts-nocheck
 const htmlTransform = require('./html-transform');
 const absoluteToTransformReady = require('./absolute-to-transform-ready');
-
+const { buildEarlyExitMatch } = require('./build-early-exit-match');
 const htmlAbsoluteToTransformReady = function (html = '', siteUrl, _options) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options || {});
-
-    // exit early and avoid parsing if the content does not contain the siteUrl
-    options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
-    options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
-
+    // exit early and avoid parsing if the content does not contain the siteUrl or configured asset bases
+    options.earlyExitMatchStr = buildEarlyExitMatch(siteUrl, options);
     // need to ignore itemPath because absoluteToRelative doesn't take that option
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
         return absoluteToTransformReady(_url, _siteUrl, __options);
     };
-
     return htmlTransform(html, siteUrl, transformFunction, '', options);
 };
-
 module.exports = htmlAbsoluteToTransformReady;

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

@@ -0,0 +1,3 @@
+declare const htmlTransform: any;
+declare const relativeToAbsolute: any;
+declare function htmlRelativeToAbsolute(html: string | undefined, siteUrl: any, itemPath: any, _options: any): any;

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

@@ -1,17 +1,15 @@
+"use strict";
+// @ts-nocheck
 const htmlTransform = require('./html-transform');
 const relativeToAbsolute = require('./relative-to-absolute');
-
 function htmlRelativeToAbsolute(html = '', siteUrl, itemPath, _options) {
-    const defaultOptions = {assetsOnly: false, secure: false};
+    const defaultOptions = { assetsOnly: false, secure: false };
     const options = Object.assign({}, defaultOptions, _options || {});
-
     // exit early and avoid parsing if the content does not contain an attribute we might transform
     options.earlyExitMatchStr = 'href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
     return htmlTransform(html, siteUrl, relativeToAbsolute, itemPath, options);
 }
-
 module.exports = htmlRelativeToAbsolute;

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

@@ -0,0 +1,3 @@
+declare const htmlTransform: any;
+declare const relativeToTransformReady: any;
+declare const htmlRelativeToTransformReady: (html: string | undefined, root: any, itemPath: any, _options: any) => any;

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

@@ -1,13 +1,13 @@
+"use strict";
+// @ts-nocheck
 const htmlTransform = require('./html-transform');
 const relativeToTransformReady = require('./relative-to-transform-ready');
-
 const htmlRelativeToTransformReady = function (html = '', root, itemPath, _options) {
     // itemPath is optional, if it's an object may be the options param instead
     if (typeof itemPath === 'object' && !_options) {
         _options = itemPath;
         itemPath = null;
     }
-
     const defaultOptions = {
         replacementStr: '__GHOST_URL__'
     };
@@ -15,14 +15,11 @@ const htmlRelativeToTransformReady = function (html = '', root, itemPath, _optio
         secure: false
     };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
     // exit early and avoid parsing if the content does not contain an attribute we might transform
     options.earlyExitMatchStr = 'href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
     return htmlTransform(html, root, relativeToTransformReady, itemPath, options);
 };
-
 module.exports = htmlRelativeToTransformReady;

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

@@ -0,0 +1,3 @@
+declare const htmlRelativeToAbsolute: any;
+declare const htmlAbsoluteToTransformReady: any;
+declare function htmlToTransformReady(html: any, siteUrl: any, itemPath: any, options: any): any;

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

@@ -1,6 +1,7 @@
+"use strict";
+// @ts-nocheck
 const htmlRelativeToAbsolute = require('./html-relative-to-absolute');
 const htmlAbsoluteToTransformReady = require('./html-absolute-to-transform-ready');
-
 function htmlToTransformReady(html, siteUrl, itemPath, options) {
     if (typeof itemPath === 'object' && !options) {
         options = itemPath;
@@ -9,5 +10,4 @@ function htmlToTransformReady(html, siteUrl, itemPath, options) {
     const absolute = htmlRelativeToAbsolute(html, siteUrl, itemPath, options);
     return htmlAbsoluteToTransformReady(absolute, siteUrl, options);
 }
-
 module.exports = htmlToTransformReady;

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

@@ -0,0 +1,4 @@
+declare const cheerio: any;
+declare function extractSrcsetUrls(srcset?: string): string[];
+declare function extractStyleUrls(style?: string): string[];
+declare function htmlTransform(html: string | undefined, siteUrl: any, transformFunction: any, itemPath: any, _options: any): string;

package/lib/utils/html-transform.js

@@ -1,36 +1,30 @@
+"use strict";
+// @ts-nocheck
+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};
+    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});
-
+    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
     //
@@ -42,17 +36,13 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
     //     ]
     // }
     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) => {
@@ -65,28 +55,24 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
                 });
                 return;
             }
-
             el = htmlContent(el);
             const originalValue = el.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));
                 let transformedValue = originalValue;
-
                 urls.forEach((url, i) => {
                     if (absoluteUrls[i]) {
                         let regex = new RegExp(escapeRegExp(url), 'g');
                         transformedValue = transformedValue.replace(regex, absoluteUrls[i]);
                     }
                 });
-
                 if (transformedValue !== originalValue) {
                     addReplacement({
                         name: attributeName,
@@ -94,9 +80,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 +93,20 @@ 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;
             }
-
             // 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 +118,6 @@ function htmlTransform(html = '', siteUrl, transformFunction, itemPath, _options
             });
         });
     }
-
     return html;
 }
-
 module.exports = htmlTransform;

package/lib/utils/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// @ts-nocheck
 module.exports = {
     absoluteToRelative: require('./absolute-to-relative'),
     absoluteToTransformReady: require('./absolute-to-transform-ready'),

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

@@ -0,0 +1,2 @@
+declare const URL: any;
+declare function isSSL(urlToParse: any): boolean;

package/lib/utils/is-ssl.js

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

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

@@ -0,0 +1,2 @@
+declare const absoluteToRelative: any;
+declare const lexicalTransform: any;

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

@@ -1,16 +1,14 @@
+"use strict";
+// @ts-nocheck
 const absoluteToRelative = require('./absolute-to-relative');
 const lexicalTransform = 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 lexicalTransform(serializedLexical, siteUrl, transformFunction, '', options);
 }
-
 module.exports = lexicalAbsoluteToRelative;

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

@@ -0,0 +1,2 @@
+declare const absoluteToTransformReady: any;
+declare const lexicalTransform: any;

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

@@ -1,16 +1,14 @@
+"use strict";
+// @ts-nocheck
 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'};
+    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 lexicalTransform(serializedLexical, siteUrl, transformFunction, '', options);
 }
-
 module.exports = lexicalAbsoluteToRelative;

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

@@ -0,0 +1,3 @@
+declare const relativeToAbsolute: any;
+declare const lexicalTransform: any;
+declare function lexicalRelativeToAbsolute(serializedLexical: any, siteUrl: any, itemPath: any, _options?: {}): any;

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

@@ -1,12 +1,11 @@
+"use strict";
+// @ts-nocheck
 const relativeToAbsolute = require('./relative-to-absolute');
 const lexicalTransform = 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);
 }
-
 module.exports = lexicalRelativeToAbsolute;

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

@@ -0,0 +1,3 @@
+declare const relativeToTransformReady: any;
+declare const lexicalTransform: any;
+declare function lexicalRelativeToTransformReady(serializedLexical: any, siteUrl: any, itemPath: any, _options?: {}): any;