@tryghost/url-utils 5.0.0 → 5.1.1

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,40 +1,117 @@
 "use strict";
-// @ts-nocheck
-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')
+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

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

package/lib/utils/is-ssl.js

@@ -1,9 +1,9 @@
 "use strict";
-// @ts-nocheck
+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

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

@@ -1,2 +1,3 @@
-declare const absoluteToTransformReady: any;
-declare const lexicalTransform: any;
+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,14 +1,17 @@
 "use strict";
-// @ts-nocheck
-const absoluteToTransformReady = require('./absolute-to-transform-ready');
-const lexicalTransform = require('./lexical-transform');
-function lexicalAbsoluteToRelative(serializedLexical, siteUrl, _options = {}) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
+const 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

@@ -1,3 +1,3 @@
-declare const relativeToAbsolute: any;
-declare const lexicalTransform: any;
-declare function lexicalRelativeToAbsolute(serializedLexical: any, siteUrl: any, itemPath: any, _options?: {}): any;
+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,11 +1,14 @@
 "use strict";
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
-const lexicalTransform = require('./lexical-transform');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+const 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 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

@@ -1,3 +1,3 @@
-declare const relativeToTransformReady: any;
-declare const lexicalTransform: any;
-declare function lexicalRelativeToTransformReady(serializedLexical: any, siteUrl: any, itemPath: any, _options?: {}): any;
+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,11 +1,14 @@
 "use strict";
-// @ts-nocheck
-const relativeToTransformReady = require('./relative-to-transform-ready');
-const lexicalTransform = require('./lexical-transform');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const relative_to_transform_ready_1 = __importDefault(require("./relative-to-transform-ready"));
+const 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 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

@@ -1,3 +1,3 @@
-declare const lexicalRelativeToAbsolute: any;
-declare const lexicalAbsoluteToTransformReady: any;
-declare function lexicalToTransformReady(lexical: any, siteUrl: any, itemPath: any, options: any): any;
+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 @@
 "use strict";
-// @ts-nocheck
-const lexicalRelativeToAbsolute = require('./lexical-relative-to-absolute');
-const lexicalAbsoluteToTransformReady = require('./lexical-absolute-to-transform-ready');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const 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

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

package/lib/utils/lexical-transform.js

@@ -1,13 +1,7 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const _ = require('lodash');
-// options.transformMap = {
-//     relativeToAbsolute: {
-//         url: (url, siteUrl, itemPath, options) => 'transformedUrl',
-//         html: (html, siteUrl, itemPath, options) => 'transformedHtml',
-//     }
-// }
-// options.transformType = 'relativeToAbsolute'
 function lexicalTransform(serializedLexical, siteUrl, transformFunction, itemPath, _options = {}) {
     const defaultOptions = { assetsOnly: false, secure: false, nodes: [], transformMap: {} };
     const options = Object.assign({}, defaultOptions, _options, { siteUrl, itemPath });
@@ -30,14 +24,20 @@ function lexicalTransform(serializedLexical, siteUrl, transformFunction, itemPat
             propertyValue.forEach((item) => {
                 // arrays of objects need to be defined as a nested object in the urlTransformMap
                 // so the `transform` value is that nested object
-                Object.entries(transform).forEach(([itemPropertyPath, itemTransform]) => {
-                    transformProperty(item, itemPropertyPath, itemTransform);
-                });
+                if (typeof transform === 'object') {
+                    Object.entries(transform).forEach(([itemPropertyPath, itemTransform]) => {
+                        transformProperty(item, itemPropertyPath, itemTransform);
+                    });
+                }
             });
             return;
         }
-        if (propertyValue) {
-            _.set(obj, propertyPath, options.transformMap[options.transformType][transform](propertyValue));
+        if (propertyValue && typeof transform === 'string') {
+            const transformType = options.transformType;
+            const transformRegistry = options.transformMap[transformType];
+            if (transformRegistry && transformRegistry[transform]) {
+                _.set(obj, propertyPath, transformRegistry[transform](propertyValue));
+            }
         }
     };
     // recursively walk the Lexical node tree transforming any card data properties and links
@@ -45,12 +45,15 @@ function lexicalTransform(serializedLexical, siteUrl, transformFunction, itemPat
         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);
-                });
+            if (isCard && child.type) {
+                const urlTransformMap = nodeMap.get(child.type);
+                if (urlTransformMap) {
+                    Object.entries(urlTransformMap).forEach(([propertyPath, transform]) => {
+                        transformProperty(child, propertyPath, transform);
+                    });
+                }
             }
-            else if (isLink) {
+            else if (isLink && child.url) {
                 child.url = transformFunction(child.url, siteUrl, itemPath, options);
             }
             if (child.children) {
@@ -61,4 +64,4 @@ function lexicalTransform(serializedLexical, siteUrl, transformFunction, itemPat
     transformChildren(lexical.root.children);
     return JSON.stringify(lexical);
 }
-module.exports = lexicalTransform;
+exports.default = lexicalTransform;

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

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

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

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

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

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

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

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

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

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