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

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;

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

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

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

@@ -0,0 +1,3 @@
+declare const lexicalRelativeToAbsolute: any;
+declare const lexicalAbsoluteToTransformReady: any;
+declare function lexicalToTransformReady(lexical: any, siteUrl: any, itemPath: any, options: any): any;

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

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

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

@@ -0,0 +1,2 @@
+declare const _: any;
+declare function lexicalTransform(serializedLexical: any, siteUrl: any, transformFunction: any, itemPath: any, _options?: {}): any;

package/lib/utils/lexical-transform.js

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

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

@@ -0,0 +1,4 @@
+declare const markdownTransform: any;
+declare const absoluteToRelative: any;
+declare const htmlAbsoluteToRelative: any;
+declare function markdownAbsoluteToRelative(markdown: string | undefined, siteUrl: any, _options?: {}): any;

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

@@ -1,14 +1,13 @@
+"use strict";
+// @ts-nocheck
 const markdownTransform = require('./markdown-transform');
 const absoluteToRelative = require('./absolute-to-relative');
 const htmlAbsoluteToRelative = require('./html-absolute-to-relative');
-
 function markdownAbsoluteToRelative(markdown = '', siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options);
-
     options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
     options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
-
     // need to ignore itemPath because absoluteToRelative functions doen't take that option
     const transformFunctions = {
         html(_url, _siteUrl, _itemPath, __options) {
@@ -18,8 +17,6 @@ function markdownAbsoluteToRelative(markdown = '', siteUrl, _options = {}) {
             return absoluteToRelative(_url, _siteUrl, __options);
         }
     };
-
     return markdownTransform(markdown, siteUrl, transformFunctions, '', options);
 }
-
 module.exports = markdownAbsoluteToRelative;

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

@@ -0,0 +1,5 @@
+declare const markdownTransform: any;
+declare const absoluteToTransformReady: any;
+declare const htmlAbsoluteToTransformReady: any;
+declare const buildEarlyExitMatch: any;
+declare function markdownAbsoluteToTransformReady(markdown: string | undefined, siteUrl: any, _options?: {}): any;

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

@@ -1,14 +1,13 @@
+"use strict";
+// @ts-nocheck
 const markdownTransform = require('./markdown-transform');
 const absoluteToTransformReady = require('./absolute-to-transform-ready');
 const htmlAbsoluteToTransformReady = require('./html-absolute-to-transform-ready');
-
+const { buildEarlyExitMatch } = require('./build-early-exit-match');
 function markdownAbsoluteToTransformReady(markdown = '', siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, ignoreProtocol: true};
+    const defaultOptions = { assetsOnly: false, ignoreProtocol: true };
     const options = Object.assign({}, defaultOptions, _options);
-
-    options.earlyExitMatchStr = options.ignoreProtocol ? siteUrl.replace(/http:|https:/, '') : siteUrl;
-    options.earlyExitMatchStr = options.earlyExitMatchStr.replace(/\/$/, '');
-
+    options.earlyExitMatchStr = buildEarlyExitMatch(siteUrl, options);
     // need to ignore itemPath because absoluteToTransformReady functions doen't take that option
     const transformFunctions = {
         html(_url, _siteUrl, _itemPath, __options) {
@@ -18,8 +17,6 @@ function markdownAbsoluteToTransformReady(markdown = '', siteUrl, _options = {})
             return absoluteToTransformReady(_url, _siteUrl, __options);
         }
     };
-
     return markdownTransform(markdown, siteUrl, transformFunctions, '', options);
 }
-
 module.exports = markdownAbsoluteToTransformReady;

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

@@ -0,0 +1,4 @@
+declare const markdownTransform: any;
+declare const htmlRelativeToAbsolute: any;
+declare const relativeToAbsolute: any;
+declare function markdownRelativeToAbsolute(markdown: string | undefined, siteUrl: any, itemPath: any, _options?: {}): any;

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

@@ -1,22 +1,19 @@
+"use strict";
+// @ts-nocheck
 const markdownTransform = require('./markdown-transform');
 const htmlRelativeToAbsolute = require('./html-relative-to-absolute');
 const relativeToAbsolute = require('./relative-to-absolute');
-
 function markdownRelativeToAbsolute(markdown = '', siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false};
+    const defaultOptions = { assetsOnly: false };
     const options = Object.assign({}, defaultOptions, _options);
-
     options.earlyExitMatchStr = '\\]\\([^\\s\\)]|href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
     const transformFunctions = {
         html: htmlRelativeToAbsolute,
         url: relativeToAbsolute
     };
-
     return markdownTransform(markdown, siteUrl, transformFunctions, itemPath, options);
 }
-
 module.exports = markdownRelativeToAbsolute;

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

@@ -0,0 +1,4 @@
+declare const markdownTransform: any;
+declare const htmlRelativeToTransformReady: any;
+declare const relativeToTransformReady: any;
+declare function markdownRelativeToTransformReady(markdown: string | undefined, siteUrl: any, itemPath: any, _options?: {}): any;

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

@@ -1,22 +1,19 @@
+"use strict";
+// @ts-nocheck
 const markdownTransform = require('./markdown-transform');
 const htmlRelativeToTransformReady = require('./html-relative-to-transform-ready');
 const relativeToTransformReady = require('./relative-to-transform-ready');
-
 function markdownRelativeToTransformReady(markdown = '', siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false};
+    const defaultOptions = { assetsOnly: false };
     const options = Object.assign({}, defaultOptions, _options);
-
     options.earlyExitMatchStr = '\\]\\([^\\s\\)]|href=|src=|srcset=';
     if (options.assetsOnly) {
         options.earlyExitMatchStr = options.staticImageUrlPrefix;
     }
-
     const transformFunctions = {
         html: htmlRelativeToTransformReady,
         url: relativeToTransformReady
     };
-
     return markdownTransform(markdown, siteUrl, transformFunctions, itemPath, options);
 }
-
 module.exports = markdownRelativeToTransformReady;

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

@@ -0,0 +1,3 @@
+declare const markdownRelativeToAbsolute: any;
+declare const markdownAbsoluteToTransformReady: any;
+declare function markdownToTransformReady(markdown: any, siteUrl: any, itemPath: any, options: any): any;

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

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

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

@@ -0,0 +1,5 @@
+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;

package/lib/utils/markdown-transform.js

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

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

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

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

@@ -1,16 +1,14 @@
+"use strict";
+// @ts-nocheck
 const absoluteToRelative = require('./absolute-to-relative');
 const mobiledocTransform = require('./mobiledoc-transform');
-
 function mobiledocAbsoluteToRelative(serializedMobiledoc, siteUrl, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
-    const overrideOptions = {siteUrl, transformType: 'absoluteToRelative'};
+    const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
+    const overrideOptions = { siteUrl, transformType: 'absoluteToRelative' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
     const transformFunction = function (_url, _siteUrl, _itemPath, __options) {
         return absoluteToRelative(_url, _siteUrl, __options);
     };
-
     return mobiledocTransform(serializedMobiledoc, siteUrl, transformFunction, '', options);
 }
-
 module.exports = mobiledocAbsoluteToRelative;

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

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

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

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

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

@@ -0,0 +1,3 @@
+declare const relativeToAbsolute: any;
+declare const mobiledocTransform: any;
+declare function mobiledocRelativeToAbsolute(serializedMobiledoc: any, siteUrl: any, itemPath: any, _options?: {}): any;

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

@@ -1,12 +1,11 @@
+"use strict";
+// @ts-nocheck
 const relativeToAbsolute = require('./relative-to-absolute');
 const mobiledocTransform = require('./mobiledoc-transform');
-
 function mobiledocRelativeToAbsolute(serializedMobiledoc, siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
-    const overrideOptions = {siteUrl, itemPath, transformType: 'relativeToAbsolute'};
+    const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
+    const overrideOptions = { siteUrl, itemPath, transformType: 'relativeToAbsolute' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
     return mobiledocTransform(serializedMobiledoc, siteUrl, relativeToAbsolute, itemPath, options);
 }
-
 module.exports = mobiledocRelativeToAbsolute;

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

@@ -0,0 +1,3 @@
+declare const relativeToTransformReady: any;
+declare const mobiledocTransform: any;
+declare function mobiledocRelativeToTransformReady(serializedMobiledoc: any, siteUrl: any, itemPath: any, _options?: {}): any;

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

@@ -1,12 +1,11 @@
+"use strict";
+// @ts-nocheck
 const relativeToTransformReady = require('./relative-to-transform-ready');
 const mobiledocTransform = require('./mobiledoc-transform');
-
 function mobiledocRelativeToTransformReady(serializedMobiledoc, siteUrl, itemPath, _options = {}) {
-    const defaultOptions = {assetsOnly: false, secure: false, cardTransformers: []};
-    const overrideOptions = {siteUrl, transformType: 'toTransformReady'};
+    const defaultOptions = { assetsOnly: false, secure: false, cardTransformers: [] };
+    const overrideOptions = { siteUrl, transformType: 'toTransformReady' };
     const options = Object.assign({}, defaultOptions, _options, overrideOptions);
-
     return mobiledocTransform(serializedMobiledoc, siteUrl, relativeToTransformReady, itemPath, options);
 }
-
 module.exports = mobiledocRelativeToTransformReady;

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

@@ -0,0 +1,3 @@
+declare const mobiledocRelativeToAbsolute: any;
+declare const mobiledocAbsoluteToTransformReady: any;
+declare function mobiledocToTransformReady(mobiledoc: any, siteUrl: any, itemPath: any, options: any): any;

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

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

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

@@ -0,0 +1 @@
+declare function mobiledocTransform(serializedMobiledoc: any, siteUrl: any, transformFunction: any, itemPath: any, _options?: {}): string;

package/lib/utils/mobiledoc-transform.js

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

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

@@ -0,0 +1,4 @@
+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;

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

@@ -1,26 +1,34 @@
+"use strict";
+// @ts-nocheck
 const absoluteToTransformReady = require('./absolute-to-transform-ready');
-
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const { escapeRegExp } = require('./build-early-exit-match');
+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);
+    const patterns = baseUrls.map((baseUrl) => {
+        const parsed = new URL(baseUrl);
+        const escapedUrl = escapeRegExp(`${parsed.hostname}${parsed.pathname.replace(/\/$/, '')}`);
+        return escapedUrl;
+    });
+    if (!patterns.length) {
+        return null;
+    }
+    const pattern = patterns.length === 1 ? patterns[0] : `(?:${patterns.join('|')})`;
+    return new RegExp(` \\[(https?://${pattern}.*?)\\]`, 'g');
 }
-
 const plaintextAbsoluteToTransformReady = function plaintextAbsoluteToTransformReady(plaintext, rootUrl, itemPath, options) {
     // itemPath is optional, if it's an object may be the options param instead
     if (typeof itemPath === 'object' && !options) {
         options = itemPath;
         itemPath = null;
     }
-
     // plaintext links look like "Link title [url]"
     // those links are all we care about so we can do a fast regex here
-    const rootURL = new URL(rootUrl);
-    const escapedRootUrl = escapeRegExp(`${rootURL.hostname}${rootURL.pathname.replace(/\/$/, '')}`);
-    const linkRegex = new RegExp(` \\[(https?://${escapedRootUrl}.*?)\\]`, 'g');
-
+    const linkRegex = buildLinkRegex(rootUrl, options);
     return plaintext.replace(linkRegex, function (fullMatch, url) {
         const newUrl = absoluteToTransformReady(`${url}`, rootUrl, options);
         return ` [${newUrl}]`;
     });
 };
-
 module.exports = plaintextAbsoluteToTransformReady;

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

@@ -0,0 +1,2 @@
+declare const relativeToTransformReady: any;
+declare const plaintextRelativeToTransformReady: (plaintext: any, rootUrl: any, itemPath: any, options: any) => any;