@tryghost/url-utils 5.0.0 → 5.1.0

package/lib/UrlUtils.js

@@ -1,8 +1,44 @@
 "use strict";
-// @ts-nocheck
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // Contains all path information to be used throughout the codebase.
-const _ = require('lodash');
-const utils = require('./utils');
+const _ = __importStar(require("lodash"));
+const utils_1 = __importDefault(require("./utils"));
 // similar to Object.assign but will not override defaults if a source value is undefined
 function assignOptions(target, ...sources) {
     const options = sources.map((x) => {
@@ -12,7 +48,12 @@ function assignOptions(target, ...sources) {
     });
     return Object.assign(target, ...options);
 }
-module.exports = class UrlUtils {
+class UrlUtils {
+    _config;
+    _assetBaseUrls;
+    getSubdir;
+    getSiteUrl;
+    getAdminUrl;
     /**
      * Initialization method to pass in URL configurations
      * @param {Object} options
@@ -48,9 +89,9 @@ module.exports = class UrlUtils {
             files: assetBaseUrls.files || null,
             media: assetBaseUrls.media || null
         };
-        this.getSubdir = options.getSubdir;
-        this.getSiteUrl = options.getSiteUrl;
-        this.getAdminUrl = options.getAdminUrl;
+        this.getSubdir = options.getSubdir || (() => '');
+        this.getSiteUrl = options.getSiteUrl || (() => '');
+        this.getAdminUrl = options.getAdminUrl || (() => '');
     }
     _assetOptionDefaults() {
         return {
@@ -66,12 +107,16 @@ module.exports = class UrlUtils {
         return assignOptions({}, this._assetOptionDefaults(), additionalDefaults, options || {});
     }
     getProtectedSlugs() {
-        let subDir = this.getSubdir();
+        const subDir = this.getSubdir();
         if (!_.isEmpty(subDir)) {
-            return this._config.slugs.concat([subDir.split('/').pop()]);
+            const lastSegment = subDir.split('/').pop();
+            if (this._config.slugs && lastSegment) {
+                return this._config.slugs.concat([lastSegment]);
+            }
+            return lastSegment ? [lastSegment] : [];
         }
         else {
-            return this._config.slugs;
+            return this._config.slugs || [];
         }
     }
     /** urlJoin
@@ -80,7 +125,7 @@ module.exports = class UrlUtils {
      * @return {string} URL concatinated URL/path of arguments.
      */
     urlJoin(...parts) {
-        return utils.urlJoin(parts, { rootUrl: this.getSiteUrl() });
+        return utils_1.default.urlJoin(parts, { rootUrl: this.getSiteUrl() });
     }
     // ## createUrl
     // Simple url creation from a given path
@@ -129,11 +174,11 @@ module.exports = class UrlUtils {
     urlFor(context, data, absolute) {
         let urlPath = '/';
         let imagePathRe;
-        let knownObjects = ['image', 'nav'];
+        const knownObjects = ['image', 'nav'];
         let baseUrl;
         let hostname;
         // this will become really big
-        let knownPaths = {
+        const knownPaths = {
             home: '/',
             sitemap_xsl: '/sitemap.xsl'
         };
@@ -142,14 +187,15 @@ module.exports = class UrlUtils {
             absolute = data;
             data = null;
         }
-        if (_.isObject(context) && context.relativeUrl) {
-            urlPath = context.relativeUrl;
+        if (_.isObject(context) && !_.isArray(context) && 'relativeUrl' in context && typeof context.relativeUrl === 'string') {
+            const relativeUrl = context.relativeUrl;
+            urlPath = relativeUrl || '/';
         }
         else if (_.isString(context) && _.indexOf(knownObjects, context) !== -1) {
-            if (context === 'image' && data.image) {
+            if (context === 'image' && data && typeof data === 'object' && !_.isArray(data) && 'image' in data && typeof data.image === 'string') {
                 urlPath = data.image;
                 imagePathRe = new RegExp('^' + this.getSubdir() + '/' + this._config.staticImageUrlPrefix);
-                absolute = imagePathRe.test(data.image) ? absolute : false;
+                absolute = imagePathRe.test(urlPath) ? (absolute || false) : false;
                 if (absolute) {
                     // Remove the sub-directory from the URL because ghostConfig will add it back.
                     urlPath = urlPath.replace(new RegExp('^' + this.getSubdir()), '');
@@ -158,7 +204,7 @@ module.exports = class UrlUtils {
                 }
                 return urlPath;
             }
-            else if (context === 'nav' && data.nav) {
+            else if (context === 'nav' && data && typeof data === 'object' && !_.isArray(data) && 'nav' in data && data.nav && typeof data.nav === 'object' && !_.isArray(data.nav) && 'url' in data.nav && typeof data.nav.url === 'string') {
                 urlPath = data.nav.url;
                 baseUrl = this.getSiteUrl();
                 hostname = baseUrl.split('//')[1];
@@ -179,12 +225,12 @@ module.exports = class UrlUtils {
             urlPath = this.getSiteUrl();
             // CASE: there are cases where urlFor('home') needs to be returned without trailing
             // slash e. g. the `{{@site.url}}` helper. See https://github.com/TryGhost/Ghost/issues/8569
-            if (data && data.trailingSlash === false) {
+            if (data && typeof data === 'object' && !_.isArray(data) && 'trailingSlash' in data && data.trailingSlash === false) {
                 urlPath = urlPath.replace(/\/$/, '');
             }
         }
         else if (context === 'admin') {
-            let adminUrl = this.getAdminUrl() || this.getSiteUrl();
+            const adminUrl = this.getAdminUrl() || this.getSiteUrl();
             let adminPath = '/ghost/';
             if (absolute) {
                 urlPath = this.urlJoin(adminUrl, adminPath);
@@ -194,9 +240,9 @@ module.exports = class UrlUtils {
             }
         }
         else if (context === 'api') {
-            let adminUrl = this.getAdminUrl() || this.getSiteUrl();
+            const adminUrl = this.getAdminUrl() || this.getSiteUrl();
             let apiPath = this._config.baseApiPath + '/';
-            if (data.type && ['admin', 'content'].includes(data.type)) {
+            if (data && typeof data === 'object' && !_.isArray(data) && 'type' in data && typeof data.type === 'string' && ['admin', 'content'].includes(data.type)) {
                 apiPath += data.type;
             }
             else {
@@ -224,52 +270,65 @@ module.exports = class UrlUtils {
     }
     redirect301(res, redirectUrl) {
         res.set({ 'Cache-Control': 'public, max-age=' + this._config.redirectCacheMaxAge });
-        return res.redirect(301, redirectUrl);
+        res.redirect(301, redirectUrl);
     }
     redirectToAdmin(status, res, adminPath) {
-        let redirectUrl = this.urlJoin(this.urlFor('admin', true), adminPath, '/');
+        const redirectUrl = this.urlJoin(this.urlFor('admin', true), adminPath, '/');
         if (status === 301) {
-            return this.redirect301(res, redirectUrl);
+            this.redirect301(res, redirectUrl);
+        }
+        else {
+            res.redirect(redirectUrl);
         }
-        return res.redirect(redirectUrl);
     }
     absoluteToRelative(url, options) {
-        return utils.absoluteToRelative(url, this.getSiteUrl(), options);
+        return utils_1.default.absoluteToRelative(url, this.getSiteUrl(), options);
     }
     relativeToAbsolute(url, options) {
-        return utils.relativeToAbsolute(url, this.getSiteUrl(), options);
+        // Original code passes options as third parameter (itemPath), preserving that behavior
+        return utils_1.default.relativeToAbsolute(url, this.getSiteUrl(), options || null, undefined);
     }
     toTransformReady(url, 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 _options = this._buildAssetOptions({}, options);
-        return utils.toTransformReady(url, this.getSiteUrl(), itemPath, _options);
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
+        }
+        const _options = this._buildAssetOptions({}, finalOptions);
+        return utils_1.default.toTransformReady(url, this.getSiteUrl(), finalItemPath, _options);
     }
     absoluteToTransformReady(url, options) {
         const _options = this._buildAssetOptions({}, options);
-        return utils.absoluteToTransformReady(url, this.getSiteUrl(), _options);
+        return utils_1.default.absoluteToTransformReady(url, this.getSiteUrl(), _options);
     }
     relativeToTransformReady(url, options) {
         const _options = this._buildAssetOptions({}, options);
-        return utils.relativeToTransformReady(url, this.getSiteUrl(), _options);
+        return utils_1.default.relativeToTransformReady(url, this.getSiteUrl(), _options);
     }
     transformReadyToAbsolute(url, options) {
         const _options = this._buildAssetOptions({}, options);
-        return utils.transformReadyToAbsolute(url, this.getSiteUrl(), _options);
+        return utils_1.default.transformReadyToAbsolute(url, this.getSiteUrl(), _options);
     }
     transformReadyToRelative(url, options) {
         const _options = this._buildAssetOptions({}, options);
-        return utils.transformReadyToRelative(url, this.getSiteUrl(), _options);
+        return utils_1.default.transformReadyToRelative(url, this.getSiteUrl(), _options);
     }
     htmlToTransformReady(html, 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 _options = this._buildAssetOptions({}, options);
-        return utils.htmlToTransformReady(html, this.getSiteUrl(), itemPath, _options);
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
+        }
+        const _options = this._buildAssetOptions({}, finalOptions);
+        return utils_1.default.htmlToTransformReady(html, this.getSiteUrl(), finalItemPath, _options);
     }
     /**
      * Convert relative URLs in html into absolute URLs
@@ -282,172 +341,227 @@ module.exports = class UrlUtils {
      * the variable that takes the result of this function
      */
     htmlRelativeToAbsolute(html, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false
-        }, options);
-        return utils.htmlRelativeToAbsolute(html, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.htmlRelativeToAbsolute(html, this.getSiteUrl(), finalItemPath, _options);
     }
     htmlRelativeToTransformReady(html, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false
-        }, options);
-        return utils.htmlRelativeToTransformReady(html, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.htmlRelativeToTransformReady(html, this.getSiteUrl(), finalItemPath, _options);
     }
     htmlAbsoluteToRelative(html, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
-        return utils.htmlAbsoluteToRelative(html, this.getSiteUrl(), _options);
+        return utils_1.default.htmlAbsoluteToRelative(html, this.getSiteUrl(), _options);
     }
     htmlAbsoluteToTransformReady(html, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
-        return utils.htmlAbsoluteToTransformReady(html, this.getSiteUrl(), _options);
+        return utils_1.default.htmlAbsoluteToTransformReady(html, this.getSiteUrl(), _options);
     }
     markdownToTransformReady(markdown, 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 _options = this._buildAssetOptions({}, options);
-        return utils.markdownToTransformReady(markdown, this.getSiteUrl(), itemPath, _options);
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
+        }
+        const _options = this._buildAssetOptions({}, finalOptions);
+        return utils_1.default.markdownToTransformReady(markdown, this.getSiteUrl(), finalItemPath, _options);
     }
     markdownRelativeToAbsolute(markdown, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false
-        }, options);
-        return utils.markdownRelativeToAbsolute(markdown, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.markdownRelativeToAbsolute(markdown, this.getSiteUrl(), finalItemPath, _options);
     }
     markdownRelativeToTransformReady(markdown, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false
-        }, options);
-        return utils.markdownRelativeToTransformReady(markdown, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.markdownRelativeToTransformReady(markdown, this.getSiteUrl(), finalItemPath, _options);
     }
     markdownAbsoluteToRelative(markdown, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
-        return utils.markdownAbsoluteToRelative(markdown, this.getSiteUrl(), _options);
+        return utils_1.default.markdownAbsoluteToRelative(markdown, this.getSiteUrl(), _options);
     }
-    markdownAbsoluteToTransformReady(markdown, options) {
+    markdownAbsoluteToTransformReady(markdown, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false
         }, options);
-        return utils.markdownAbsoluteToTransformReady(markdown, this.getSiteUrl(), _options);
+        return utils_1.default.markdownAbsoluteToTransformReady(markdown, this.getSiteUrl(), _options);
     }
     mobiledocToTransformReady(serializedMobiledoc, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             cardTransformers: this._config.cardTransformers
-        }, options);
-        return utils.mobiledocToTransformReady(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.mobiledocToTransformReady(serializedMobiledoc, this.getSiteUrl(), finalItemPath, _options);
     }
     mobiledocRelativeToAbsolute(serializedMobiledoc, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
-        }, options);
-        return utils.mobiledocRelativeToAbsolute(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.mobiledocRelativeToAbsolute(serializedMobiledoc, this.getSiteUrl(), finalItemPath, _options);
     }
     mobiledocRelativeToTransformReady(serializedMobiledoc, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
-        }, options);
-        return utils.mobiledocRelativeToTransformReady(serializedMobiledoc, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.mobiledocRelativeToTransformReady(serializedMobiledoc, this.getSiteUrl(), finalItemPath, _options);
     }
     mobiledocAbsoluteToRelative(serializedMobiledoc, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
         }, options);
-        return utils.mobiledocAbsoluteToRelative(serializedMobiledoc, this.getSiteUrl(), _options);
+        return utils_1.default.mobiledocAbsoluteToRelative(serializedMobiledoc, this.getSiteUrl(), _options);
     }
     mobiledocAbsoluteToTransformReady(serializedMobiledoc, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
         }, options);
-        return utils.mobiledocAbsoluteToTransformReady(serializedMobiledoc, this.getSiteUrl(), _options);
+        return utils_1.default.mobiledocAbsoluteToTransformReady(serializedMobiledoc, this.getSiteUrl(), _options);
     }
     lexicalToTransformReady(serializedLexical, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             cardTransformers: this._config.cardTransformers
-        }, options);
-        return utils.lexicalToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.lexicalToTransformReady(serializedLexical, this.getSiteUrl(), finalItemPath, _options);
     }
     lexicalRelativeToAbsolute(serializedLexical, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
-        }, options);
-        return utils.lexicalRelativeToAbsolute(serializedLexical, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.lexicalRelativeToAbsolute(serializedLexical, this.getSiteUrl(), finalItemPath, _options);
     }
     lexicalRelativeToTransformReady(serializedLexical, 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;
+        }
+        else if (typeof itemPath === 'string') {
+            finalItemPath = itemPath;
         }
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
-        }, options);
-        return utils.lexicalRelativeToTransformReady(serializedLexical, this.getSiteUrl(), itemPath, _options);
+        }, finalOptions);
+        return utils_1.default.lexicalRelativeToTransformReady(serializedLexical, this.getSiteUrl(), finalItemPath, _options);
     }
     lexicalAbsoluteToRelative(serializedLexical, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
         }, options);
-        return utils.lexicalAbsoluteToRelative(serializedLexical, this.getSiteUrl(), _options);
+        return utils_1.default.lexicalAbsoluteToRelative(serializedLexical, this.getSiteUrl(), _options);
     }
     lexicalAbsoluteToTransformReady(serializedLexical, options = {}) {
         const _options = this._buildAssetOptions({
             assetsOnly: false,
             cardTransformers: this._config.cardTransformers
         }, options);
-        return utils.lexicalAbsoluteToTransformReady(serializedLexical, this.getSiteUrl(), _options);
+        return utils_1.default.lexicalAbsoluteToTransformReady(serializedLexical, this.getSiteUrl(), _options);
     }
     plaintextToTransformReady(plaintext, options = {}) {
         const _options = this._buildAssetOptions({}, options);
-        return utils.plaintextToTransformReady(plaintext, this.getSiteUrl(), _options);
+        return utils_1.default.plaintextToTransformReady(plaintext, this.getSiteUrl(), null, _options);
     }
     /**
      * Return whether the provided URL is part of the site (checks if same domain and within subdirectory)
@@ -466,13 +580,13 @@ module.exports = class UrlUtils {
         return false;
     }
     get isSSL() {
-        return utils.isSSL;
+        return utils_1.default.isSSL;
     }
     get replacePermalink() {
-        return utils.replacePermalink;
+        return utils_1.default.replacePermalink;
     }
     get deduplicateDoubleSlashes() {
-        return utils.deduplicateDoubleSlashes;
+        return utils_1.default.deduplicateDoubleSlashes;
     }
     /**
      * If you request **any** image in Ghost, it get's served via
@@ -494,6 +608,8 @@ module.exports = class UrlUtils {
     }
     // expose underlying functions to ease testing
     get _utils() {
-        return utils;
+        return utils_1.default;
     }
-};
+}
+exports.default = UrlUtils;
+;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import UrlUtils from './UrlUtils';
+export = UrlUtils;

package/lib/index.js

@@ -0,0 +1,6 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const UrlUtils_1 = __importDefault(require("./UrlUtils"));
+module.exports = UrlUtils_1.default;

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

@@ -1,5 +1,10 @@
-declare const URL: any;
-declare const stripSubdirectoryFromPath: any;
+export interface AbsoluteToRelativeOptions {
+    ignoreProtocol: boolean;
+    withoutSubdirectory: boolean;
+    assetsOnly: boolean;
+    staticImageUrlPrefix: string;
+}
+export type AbsoluteToRelativeOptionsInput = Partial<AbsoluteToRelativeOptions>;
 /**
  * Convert an absolute URL to a root-relative path if it matches the supplied root domain.
  *
@@ -10,4 +15,5 @@ declare const stripSubdirectoryFromPath: any;
  * @param {boolean} [options.withoutSubdirectory=false] Strip the root subdirectory from the returned path
  * @returns {string} The passed-in url or a relative path
  */
-declare const absoluteToRelative: (url: any, rootUrl: any, _options?: {}) => any;
+declare const absoluteToRelative: (url: string, rootUrl?: string, _options?: AbsoluteToRelativeOptionsInput) => string;
+export default absoluteToRelative;