@tryghost/url-utils 5.0.0 → 5.1.1

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

@@ -1,8 +1,10 @@
 "use strict";
-// @ts-nocheck
-// require the whatwg compatible URL library (same behaviour in node and browser)
-const { URL } = require('url');
-const urlJoin = require('./url-join');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
+const url_join_1 = __importDefault(require("./url-join"));
 // NOTE: Ghost's relative->absolute handling is a little strange when the rootUrl
 // includes a subdirectory. Root-relative paths such as /content/image.jpg are
 // actually treated as subdirectory-relative. This means that it's possible to
@@ -23,20 +25,25 @@ const urlJoin = require('./url-join');
  */
 const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath, _options) {
     // itemPath is optional, if it's an object it may be the options param instead
-    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;
     }
     // itemPath could be sent as a full url in which case, extract the pathname
-    if (itemPath && itemPath.match(/^http/)) {
-        const itemUrl = new URL(itemPath);
-        itemPath = itemUrl.pathname;
+    if (finalItemPath && finalItemPath.match(/^http/)) {
+        const itemUrl = new url_1.URL(finalItemPath);
+        finalItemPath = itemUrl.pathname;
     }
     const defaultOptions = {
         assetsOnly: false,
         staticImageUrlPrefix: 'content/images'
     };
-    const options = Object.assign({}, defaultOptions, _options);
+    const options = Object.assign({}, defaultOptions, finalOptions);
     // return the path as-is if it's not an asset path and we're only modifying assets
     if (options.assetsOnly) {
         const staticImageUrlPrefixRegex = new RegExp(options.staticImageUrlPrefix);
@@ -46,7 +53,7 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
     }
     // if URL is absolute return it as-is
     try {
-        const parsed = new URL(path, 'http://relative');
+        const parsed = new url_1.URL(path, 'http://relative');
         if (parsed.origin !== 'http://relative') {
             return path;
         }
@@ -55,7 +62,7 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
             return path;
         }
     }
-    catch (e) {
+    catch {
         return path;
     }
     // return the path as-is if it's a pure hash param
@@ -63,20 +70,20 @@ const relativeToAbsolute = function relativeToAbsolute(path, rootUrl, itemPath,
         return path;
     }
     // return the path as-is if it's not root-relative and we have no itemPath
-    if (!itemPath && !path.match(/^\//)) {
+    if (!finalItemPath && !path.match(/^\//)) {
         return path;
     }
     // force root to always have a trailing-slash for consistent behaviour
     if (!rootUrl.endsWith('/')) {
         rootUrl = `${rootUrl}/`;
     }
-    const parsedRootUrl = new URL(rootUrl);
-    const basePath = path.startsWith('/') ? '' : itemPath;
-    const fullPath = urlJoin([parsedRootUrl.pathname, basePath, path], { rootUrl });
-    const absoluteUrl = new URL(fullPath, rootUrl);
+    const parsedRootUrl = new url_1.URL(rootUrl);
+    const basePath = path.startsWith('/') ? '' : (finalItemPath || '');
+    const fullPath = (0, url_join_1.default)([parsedRootUrl.pathname, basePath, path], { rootUrl });
+    const absoluteUrl = new url_1.URL(fullPath, rootUrl);
     if (options.secure) {
         absoluteUrl.protocol = 'https:';
     }
     return absoluteUrl.toString();
 };
-module.exports = relativeToAbsolute;
+exports.default = relativeToAbsolute;

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

@@ -1,2 +1,8 @@
-declare const relativeToAbsolute: any;
-declare const relativeToTransformReady: (url: any, root: any, itemPath: any, _options: any) => any;
+import type { TransformReadyReplacementOptions } from './types';
+export interface RelativeToTransformReadyOptions extends TransformReadyReplacementOptions {
+    staticImageUrlPrefix: string;
+    secure: boolean;
+}
+export type RelativeToTransformReadyOptionsInput = Partial<RelativeToTransformReadyOptions>;
+declare const relativeToTransformReady: (url: string, root: string, itemPath: string | null | RelativeToTransformReadyOptionsInput, _options?: RelativeToTransformReadyOptionsInput) => string;
+export default relativeToTransformReady;

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

@@ -1,11 +1,20 @@
 "use strict";
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
+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 url_1 = require("url");
 const relativeToTransformReady = function (url, root, itemPath, _options) {
     // itemPath is optional, if it's an object may be the options param instead
-    if (typeof itemPath === 'object' && !_options) {
-        _options = itemPath;
-        itemPath = null;
+    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 defaultOptions = {
         replacementStr: '__GHOST_URL__',
@@ -14,22 +23,25 @@ const relativeToTransformReady = function (url, root, itemPath, _options) {
     const overrideOptions = {
         secure: false
     };
-    const options = Object.assign({}, defaultOptions, _options, overrideOptions);
+    const options = Object.assign({}, defaultOptions, finalOptions, overrideOptions);
     // convert to absolute
-    const absoluteUrl = relativeToAbsolute(url, root, itemPath, options);
+    const absoluteUrl = (0, relative_to_absolute_1.default)(url, root, finalItemPath, options);
     if (absoluteUrl === url) {
         return url;
     }
-    const rootUrl = new URL(root);
+    const rootUrl = new url_1.URL(root);
     const rootPathname = rootUrl.pathname.replace(/\/$/, '');
     // only convert to transform-ready if root url has no subdirectory or the subdirectory matches
     if (!url.match(/^\//) || rootPathname === '' || url.indexOf(rootPathname) === 0 || url.indexOf(`/${options.staticImageUrlPrefix}`) === 0) {
+        // normalize root to match the protocol of absoluteUrl (in case secure option changed it)
+        const absoluteUrlParsed = new url_1.URL(absoluteUrl);
+        const normalizedRoot = `${absoluteUrlParsed.protocol}//${rootUrl.host}${rootUrl.pathname}`.replace(/\/$/, '');
         // replace root with replacement string
         const transformedUrl = absoluteUrl
-            .replace(root, `${options.replacementStr}/`) // always have trailing slash after magic string
+            .replace(normalizedRoot, `${options.replacementStr}/`) // always have trailing slash after magic string
             .replace(/([^:])\/\//g, '$1/');
         return transformedUrl;
     }
     return url;
 };
-module.exports = relativeToTransformReady;
+exports.default = relativeToTransformReady;

package/lib/utils/replace-permalink.d.ts

@@ -1,5 +1,16 @@
-declare const moment: any;
+interface PermalinkResource {
+    published_at?: string | number | Date | null;
+    primary_author?: {
+        slug: string;
+    } | null;
+    primary_tag?: {
+        slug: string;
+    } | null;
+    slug: string;
+    id: string;
+}
 /**
  * creates the url path for a post based on blog timezone and permalink pattern
  */
-declare function replacePermalink(permalink: any, resource: any, timezone?: string): any;
+declare function replacePermalink(permalink: string, resource: PermalinkResource, timezone?: string): string;
+export default replacePermalink;

package/lib/utils/replace-permalink.js

@@ -1,11 +1,43 @@
 "use strict";
-// @ts-nocheck
-const moment = require('moment-timezone');
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment = __importStar(require("moment-timezone"));
 /**
  * creates the url path for a post based on blog timezone and permalink pattern
  */
 function replacePermalink(permalink, resource, timezone = 'UTC') {
-    const output = permalink;
     const primaryTagFallback = 'all';
     const publishedAtMoment = moment.tz(resource.published_at || Date.now(), timezone);
     const permalinkLookUp = {
@@ -19,7 +51,7 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
             return publishedAtMoment.format('DD');
         },
         author: function () {
-            return resource.primary_author.slug;
+            return resource.primary_author?.slug ?? 'undefined';
         },
         primary_author: function () {
             return resource.primary_author ? resource.primary_author.slug : primaryTagFallback;
@@ -36,10 +68,14 @@ function replacePermalink(permalink, resource, timezone = 'UTC') {
     };
     // replace tags like :slug or :year with actual values
     const permalinkKeys = Object.keys(permalinkLookUp);
-    return output.replace(/(:[a-z_]+)/g, function (match) {
-        if (permalinkKeys.includes(match.substr(1))) {
-            return permalinkLookUp[match.substr(1)]();
+    return permalink.replace(/(:[a-z_]+)/g, function (match) {
+        const key = match.slice(1);
+        if (permalinkKeys.includes(key)) {
+            // Known route segment - use the lookup function
+            return permalinkLookUp[key]();
         }
+        // Unknown route segment - return 'undefined' string
+        return 'undefined';
     });
 }
-module.exports = replacePermalink;
+exports.default = replacePermalink;

package/lib/utils/strip-subdirectory-from-path.d.ts

@@ -1,4 +1,3 @@
-declare const URL: any;
 /**
  * Removes the directory in the root url from the relative path
  *
@@ -7,3 +6,4 @@ declare const URL: any;
  * @returns {string} Path relative to the rootUrl's path
  */
 declare const stripSubdirectoryFromPath: (path?: string, rootUrl?: string) => string;
+export default stripSubdirectoryFromPath;

package/lib/utils/strip-subdirectory-from-path.js

@@ -1,6 +1,6 @@
 "use strict";
-// @ts-nocheck
-const { URL } = require('url');
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 /**
  * Removes the directory in the root url from the relative path
  *
@@ -15,9 +15,9 @@ const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path = '',
     }
     let parsedRoot;
     try {
-        parsedRoot = new URL(rootUrl);
+        parsedRoot = new url_1.URL(rootUrl);
     }
-    catch (e) {
+    catch {
         return path;
     }
     // do nothing if rootUrl does not have a subdirectory
@@ -29,4 +29,4 @@ const stripSubdirectoryFromPath = function stripSubdirectoryFromPath(path = '',
     }
     return path;
 };
-module.exports = stripSubdirectoryFromPath;
+exports.default = stripSubdirectoryFromPath;

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

@@ -1,3 +1,5 @@
-declare const relativeToAbsolute: any;
-declare const absoluteToTransformReady: any;
-declare function toTransformReady(url: any, siteUrl: any, itemPath: any, options: any): any;
+import type { AbsoluteToTransformReadyOptionsInput } from './absolute-to-transform-ready';
+import { type RelativeToAbsoluteOptionsInput } from './relative-to-absolute';
+export type ToTransformReadyOptions = RelativeToAbsoluteOptionsInput & AbsoluteToTransformReadyOptionsInput;
+declare function toTransformReady(url: string, siteUrl: string, itemPath: string | null | ToTransformReadyOptions, options?: ToTransformReadyOptions): string;
+export default toTransformReady;

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

@@ -1,13 +1,21 @@
 "use strict";
-// @ts-nocheck
-const relativeToAbsolute = require('./relative-to-absolute');
-const absoluteToTransformReady = require('./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 relative_to_absolute_1 = __importDefault(require("./relative-to-absolute"));
+const absolute_to_transform_ready_1 = __importDefault(require("./absolute-to-transform-ready"));
 function toTransformReady(url, 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 absoluteUrl = relativeToAbsolute(url, siteUrl, itemPath, options);
-    return absoluteToTransformReady(absoluteUrl, siteUrl, options);
+    else if (typeof itemPath === 'string') {
+        finalItemPath = itemPath;
+    }
+    const absoluteUrl = (0, relative_to_absolute_1.default)(url, siteUrl, finalItemPath, finalOptions);
+    return (0, absolute_to_transform_ready_1.default)(absoluteUrl, siteUrl, finalOptions);
 }
-module.exports = toTransformReady;
+exports.default = toTransformReady;

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

@@ -1 +1,9 @@
-declare const transformReadyToAbsolute: (str: string | undefined, root: any, _options?: {}) => string;
+import type { TransformReadyReplacementOptions, BaseUrlOptions } from './types';
+export interface TransformReadyToAbsoluteOptions extends TransformReadyReplacementOptions, BaseUrlOptions {
+    staticImageUrlPrefix: string;
+    staticFilesUrlPrefix: string;
+    staticMediaUrlPrefix: string;
+}
+export type TransformReadyToAbsoluteOptionsInput = Partial<TransformReadyToAbsoluteOptions>;
+declare const transformReadyToAbsolute: (str: string | undefined, root: string, _options?: TransformReadyToAbsoluteOptionsInput) => string;
+export default transformReadyToAbsolute;

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

@@ -1,5 +1,5 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -32,4 +32,4 @@ const transformReadyToAbsolute = function (str = '', root, _options = {}) {
         return root.replace(/\/$/, '');
     });
 };
-module.exports = transformReadyToAbsolute;
+exports.default = transformReadyToAbsolute;

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

@@ -1 +1,3 @@
-declare const transformReadyToRelative: (str: string | undefined, root: any, _options?: {}) => string;
+import type { TransformReadyReplacementOptionsInput } from './types';
+declare const transformReadyToRelative: (str: string | undefined, root: string, _options?: TransformReadyReplacementOptionsInput) => string;
+export default transformReadyToRelative;

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

@@ -1,5 +1,6 @@
 "use strict";
-// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = require("url");
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -11,10 +12,10 @@ const transformReadyToRelative = function (str = '', root, _options = {}) {
     if (!str || str.indexOf(options.replacementStr) === -1) {
         return str;
     }
-    const rootURL = new URL(root);
+    const rootURL = new url_1.URL(root);
     // subdir with no trailing slash because we'll always have a trailing slash after the magic string
     const subdir = rootURL.pathname.replace(/\/$/, '');
     const replacementRegex = new RegExp(escapeRegExp(options.replacementStr), 'g');
     return str.replace(replacementRegex, subdir);
 };
-module.exports = transformReadyToRelative;
+exports.default = transformReadyToRelative;

package/lib/utils/types.d.ts

@@ -0,0 +1,92 @@
+export type UnknownRecord = Record<string, unknown>;
+export interface AssetAwareOptions extends UnknownRecord {
+    assetsOnly: boolean;
+    staticImageUrlPrefix?: string;
+}
+export type AssetAwareOptionsInput = Partial<AssetAwareOptions>;
+export interface SecureOptions extends AssetAwareOptions {
+    secure?: boolean;
+}
+export type SecureOptionsInput = Partial<SecureOptions>;
+export interface TransformReadyReplacementOptions extends UnknownRecord {
+    replacementStr: string;
+    withoutSubdirectory?: boolean;
+}
+export type TransformReadyReplacementOptionsInput = Partial<TransformReadyReplacementOptions>;
+export interface BaseUrlOptions extends UnknownRecord {
+    imageBaseUrl?: string | null;
+    filesBaseUrl?: string | null;
+    mediaBaseUrl?: string | null;
+}
+export type BaseUrlOptionsInput = Partial<BaseUrlOptions>;
+export interface EarlyExitOptions extends UnknownRecord {
+    earlyExitMatchStr?: string;
+}
+export type EarlyExitOptionsInput = Partial<EarlyExitOptions>;
+export interface AbsoluteToTransformReadyOptions extends TransformReadyReplacementOptions, BaseUrlOptions, AssetAwareOptions {
+    staticFilesUrlPrefix?: string;
+    staticMediaUrlPrefix?: string;
+}
+export type AbsoluteToTransformReadyOptionsInput = Partial<AbsoluteToTransformReadyOptions>;
+export type UrlTransformFunction = (url: string, siteUrl: string, itemPath: string | null, options: UnknownRecord) => string;
+export type TransformType = 'relativeToAbsolute' | 'absoluteToRelative' | 'toTransformReady';
+export interface HtmlTransformOptions extends SecureOptions {
+    earlyExitMatchStr?: string;
+}
+export type HtmlTransformOptionsInput = SecureOptionsInput & {
+    earlyExitMatchStr?: string;
+};
+export interface MarkdownTransformOptions extends AssetAwareOptions {
+    ignoreProtocol: boolean;
+    earlyExitMatchStr?: string;
+}
+export type MarkdownTransformOptionsInput = AssetAwareOptionsInput & {
+    ignoreProtocol?: boolean;
+    earlyExitMatchStr?: string;
+};
+export interface MarkdownTransformFunctions {
+    html: UrlTransformFunction;
+    url: UrlTransformFunction;
+}
+export type CardTransformer = (payload: unknown, options: UnknownRecord) => unknown;
+export interface MobiledocCardTransformer {
+    name: string;
+    relativeToAbsolute?: CardTransformer;
+    absoluteToRelative?: CardTransformer;
+    toTransformReady?: CardTransformer;
+}
+export interface MobiledocTransformOptions extends SecureOptions {
+    cardTransformers: MobiledocCardTransformer[];
+    siteUrl: string;
+    itemPath: string | null;
+    transformType: TransformType;
+}
+export type MobiledocTransformOptionsInput = Partial<Omit<MobiledocTransformOptions, 'cardTransformers' | 'siteUrl' | 'itemPath' | 'transformType'>> & {
+    cardTransformers?: MobiledocCardTransformer[];
+    siteUrl?: string;
+    itemPath?: string | null;
+    transformType?: TransformType;
+};
+export type LexicalTransformFunction = (value: string) => string;
+export interface LexicalUrlTransformMap {
+    [key: string]: string | LexicalUrlTransformMap;
+}
+export interface LexicalNodeConfig {
+    getType(): string;
+    urlTransformMap?: LexicalUrlTransformMap;
+}
+export type LexicalTransformRegistry = Partial<Record<TransformType, Record<string, LexicalTransformFunction>>>;
+export interface LexicalTransformOptions extends SecureOptions {
+    nodes: LexicalNodeConfig[];
+    transformMap: LexicalTransformRegistry;
+    transformType: TransformType;
+    siteUrl: string;
+    itemPath: string | null;
+}
+export type LexicalTransformOptionsInput = Partial<Omit<LexicalTransformOptions, 'nodes' | 'transformMap' | 'siteUrl' | 'itemPath' | 'transformType'>> & {
+    nodes?: LexicalNodeConfig[];
+    transformMap?: LexicalTransformRegistry;
+    siteUrl?: string;
+    itemPath?: string | null;
+    transformType?: TransformType;
+};

package/lib/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/url-join.d.ts

@@ -1,4 +1,6 @@
-declare const deduplicateSubdirectory: any;
+interface UrlJoinOptions {
+    rootUrl: string;
+}
 /** urlJoin
 * Returns a URL/path for internal use in Ghost.
 * @param {string[]} parts takes parts and concats those to a valid path/URL.
@@ -6,4 +8,5 @@ declare const deduplicateSubdirectory: any;
 * @param {string} options.rootUrl used for deduplicating any subdirectories
 * @return {string} URL concatinated URL/path of arguments.
 */
-declare function urlJoin(parts: any, options: any): any;
+declare function urlJoin(parts: string[], options?: UrlJoinOptions): string;
+export default urlJoin;

package/lib/utils/url-join.js

@@ -1,6 +1,9 @@
 "use strict";
-// @ts-nocheck
-const deduplicateSubdirectory = require('./deduplicate-subdirectory');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deduplicate_subdirectory_1 = __importDefault(require("./deduplicate-subdirectory"));
 /** urlJoin
 * Returns a URL/path for internal use in Ghost.
 * @param {string[]} parts takes parts and concats those to a valid path/URL.
@@ -8,7 +11,7 @@ const deduplicateSubdirectory = require('./deduplicate-subdirectory');
 * @param {string} options.rootUrl used for deduplicating any subdirectories
 * @return {string} URL concatinated URL/path of arguments.
 */
-function urlJoin(parts, options) {
+function urlJoin(parts, options = { rootUrl: '' }) {
     let prefixDoubleSlash = false;
     // Remove empty item at the beginning
     if (parts[0] === '') {
@@ -26,6 +29,9 @@ function urlJoin(parts, options) {
     if (prefixDoubleSlash) {
         url = url.replace(/^\//, '//');
     }
-    return deduplicateSubdirectory(url, options.rootUrl);
+    if (!options.rootUrl) {
+        return url;
+    }
+    return (0, deduplicate_subdirectory_1.default)(url, options.rootUrl);
 }
-module.exports = urlJoin;
+exports.default = urlJoin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryghost/url-utils",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TryGhost/SDK.git",
@@ -8,26 +8,25 @@
   },
   "author": "Ghost Foundation",
   "license": "MIT",
-  "main": "index.js",
-  "types": "lib/UrlUtils.d.ts",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "scripts": {
     "dev": "echo \"Implement me!\"",
     "pretest": "yarn build",
     "test": "NODE_ENV=testing c8 --src lib --all --reporter text --reporter cobertura --reporter html mocha './test/**/*.test.js'",
     "build": "tsc -p tsconfig.json",
-    "lint": "eslint src test index.js --ext .js,.ts --cache",
+    "lint": "eslint src test --ext .js,.ts --cache",
     "prepare": "NODE_ENV=production yarn build",
     "posttest": "yarn lint"
   },
   "files": [
-    "lib/",
-    "index.js"
+    "lib/"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@tryghost/config-url-helpers": "^1.0.19",
+    "@tryghost/config-url-helpers": "^1.0.20",
     "@types/cheerio": "^0.22.31",
     "@types/lodash": "^4.14.202",
     "@types/node": "^20.0.0",
@@ -35,7 +34,7 @@
     "mocha": "11.7.5",
     "rewire": "9.0.1",
     "should": "13.2.3",
-    "sinon": "21.0.0",
+    "sinon": "21.0.1",
     "typescript": "5.9.3"
   },
   "dependencies": {
@@ -43,9 +42,9 @@
     "lodash": "^4.17.21",
     "moment": "^2.27.0",
     "moment-timezone": "^0.5.31",
-    "remark": "^11.0.2",
-    "remark-footnotes": "^1.0.0",
+    "remark": "11.0.2",
+    "remark-footnotes": "1.0.0",
     "unist-util-visit": "^2.0.0"
   },
-  "gitHead": "91913b7a8e8afc3ddc411eceacb3d5b271671bd6"
+  "gitHead": "a5b249c5514742350f74bcb30b332977d373598a"
 }

package/index.js

@@ -1,2 +0,0 @@
-module.exports = require('./lib/UrlUtils');
-