@hyperfrontend/versioning 0.1.0 → 0.3.0

package/repository/parse/index.cjs.js

@@ -0,0 +1,755 @@
+'use strict';
+
+/**
+ * Safe copies of Math built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
+ */
+// Capture references at module initialization time
+const _Math = globalThis.Math;
+/**
+ * (Safe copy) Returns the smaller of zero or more numbers.
+ */
+const min = _Math.min;
+
+/**
+ * Safe copies of URL built-ins via factory functions.
+ *
+ * Provides safe references to URL and URLSearchParams.
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/url
+ */
+// Capture references at module initialization time
+const _URL = globalThis.URL;
+const _Reflect$2 = globalThis.Reflect;
+// ============================================================================
+// URL
+// ============================================================================
+/**
+ * (Safe copy) Creates a new URL using the captured URL constructor.
+ * Use this instead of `new URL()`.
+ *
+ * @param url - The URL string to parse.
+ * @param base - Optional base URL for relative URLs.
+ * @returns A new URL instance.
+ */
+const createURL = (url, base) => _Reflect$2.construct(_URL, [url, base]);
+/**
+ * (Safe copy) Creates an object URL for the given object.
+ * Use this instead of `URL.createObjectURL()`.
+ *
+ * Note: This is a browser-only API. In Node.js environments, this will throw.
+ */
+typeof _URL.createObjectURL === 'function'
+    ? _URL.createObjectURL.bind(_URL)
+    : () => {
+        throw new Error('URL.createObjectURL is not available in this environment');
+    };
+/**
+ * (Safe copy) Revokes an object URL previously created with createObjectURL.
+ * Use this instead of `URL.revokeObjectURL()`.
+ *
+ * Note: This is a browser-only API. In Node.js environments, this will throw.
+ */
+typeof _URL.revokeObjectURL === 'function'
+    ? _URL.revokeObjectURL.bind(_URL)
+    : () => {
+        throw new Error('URL.revokeObjectURL is not available in this environment');
+    };
+
+/**
+ * Safe copies of Map built-in via factory function.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/map
+ */
+// Capture references at module initialization time
+const _Map = globalThis.Map;
+const _Reflect$1 = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Map using the captured Map constructor.
+ * Use this instead of `new Map()`.
+ *
+ * @param iterable - Optional iterable of key-value pairs.
+ * @returns A new Map instance.
+ */
+const createMap = (iterable) => _Reflect$1.construct(_Map, iterable ? [iterable] : []);
+
+/**
+ * Known platform hostnames mapped to their platform type.
+ * Used for automatic platform detection from repository URLs.
+ *
+ * Includes both standard SaaS domains and common patterns for self-hosted instances.
+ */
+const PLATFORM_HOSTNAMES = createMap([
+    // GitHub
+    ['github.com', 'github'],
+    // GitLab
+    ['gitlab.com', 'gitlab'],
+    // Bitbucket
+    ['bitbucket.org', 'bitbucket'],
+    // Azure DevOps
+    ['dev.azure.com', 'azure-devops'],
+    ['visualstudio.com', 'azure-devops'],
+]);
+/**
+ * Detects platform from a hostname.
+ *
+ * First checks for exact match in known platforms, then applies heuristics
+ * for self-hosted instances (e.g., `github.company.com` → `github`).
+ *
+ * @param hostname - Hostname to detect platform from (e.g., "github.com")
+ * @returns Detected platform or 'unknown' if not recognized
+ *
+ * @example
+ * ```typescript
+ * detectPlatformFromHostname('github.com')           // 'github'
+ * detectPlatformFromHostname('gitlab.mycompany.com') // 'gitlab'
+ * detectPlatformFromHostname('custom-git.internal')  // 'unknown'
+ * ```
+ */
+function detectPlatformFromHostname(hostname) {
+    const normalized = hostname.toLowerCase();
+    // Check exact matches first
+    const exactMatch = PLATFORM_HOSTNAMES.get(normalized);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    // Check for Azure DevOps legacy domain pattern
+    if (normalized.endsWith('.visualstudio.com')) {
+        return 'azure-devops';
+    }
+    // Check for Azure DevOps modern domain pattern (includes ssh.dev.azure.com)
+    if (normalized.endsWith('.azure.com')) {
+        return 'azure-devops';
+    }
+    // Heuristics for self-hosted instances
+    // GitHub Enterprise typically uses "github" in the hostname
+    if (normalized.includes('github')) {
+        return 'github';
+    }
+    // GitLab self-hosted typically uses "gitlab" in the hostname
+    if (normalized.includes('gitlab')) {
+        return 'gitlab';
+    }
+    // Bitbucket Data Center/Server might use "bitbucket" in hostname
+    if (normalized.includes('bitbucket')) {
+        return 'bitbucket';
+    }
+    return 'unknown';
+}
+
+/**
+ * Safe copies of Error built-ins via factory functions.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides factory functions that use Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
+ */
+// Capture references at module initialization time
+const _Error = globalThis.Error;
+const _Reflect = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Error using the captured Error constructor.
+ * Use this instead of `new Error()`.
+ *
+ * @param message - Optional error message.
+ * @param options - Optional error options.
+ * @returns A new Error instance.
+ */
+const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
+
+/**
+ * Creates a new RepositoryConfig.
+ *
+ * Normalizes the base URL by stripping trailing slashes and validating
+ * that custom platforms have a formatter function.
+ *
+ * @param options - Repository configuration options
+ * @returns A new RepositoryConfig object
+ * @throws {Error} if platform is 'custom' but no formatCompareUrl is provided
+ *
+ * @example
+ * ```typescript
+ * // GitHub repository
+ * const config = createRepositoryConfig({
+ *   platform: 'github',
+ *   baseUrl: 'https://github.com/owner/repo'
+ * })
+ *
+ * // Custom platform
+ * const customConfig = createRepositoryConfig({
+ *   platform: 'custom',
+ *   baseUrl: 'https://my-git.internal/repo',
+ *   formatCompareUrl: (from, to) => `https://my-git.internal/diff/${from}/${to}`
+ * })
+ * ```
+ */
+function createRepositoryConfig(options) {
+    const { platform, formatCompareUrl } = options;
+    // Validate custom platform has formatter
+    if (platform === 'custom' && !formatCompareUrl) {
+        throw createError("Repository config with platform 'custom' requires a formatCompareUrl function");
+    }
+    // Normalize base URL - strip trailing slashes
+    const baseUrl = normalizeBaseUrl(options.baseUrl);
+    return {
+        platform,
+        baseUrl,
+        formatCompareUrl,
+    };
+}
+/**
+ * Normalizes a base URL by stripping trailing slashes and .git suffix.
+ *
+ * @param url - URL to normalize
+ * @returns Normalized URL
+ *
+ * @internal
+ */
+function normalizeBaseUrl(url) {
+    let normalized = url.trim();
+    // Remove trailing slashes
+    while (normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    // Remove .git suffix if present
+    if (normalized.endsWith('.git')) {
+        normalized = normalized.slice(0, -4);
+    }
+    return normalized;
+}
+
+/**
+ * Parses a git URL and extracts platform and base URL.
+ *
+ * Supports multiple URL formats:
+ * - `https://github.com/owner/repo`
+ * - `https://github.com/owner/repo.git`
+ * - `git+https://github.com/owner/repo.git`
+ * - `git://github.com/owner/repo.git`
+ * - `git@github.com:owner/repo.git` (SSH format)
+ *
+ * Handles self-hosted instances by detecting platform from hostname:
+ * - `github.mycompany.com` → `github`
+ * - `gitlab.internal.com` → `gitlab`
+ *
+ * Handles Azure DevOps URL formats:
+ * - `https://dev.azure.com/org/project/_git/repo`
+ * - `https://org.visualstudio.com/project/_git/repo`
+ *
+ * @param gitUrl - Git repository URL in any supported format
+ * @returns Parsed repository info with platform and base URL, or null if parsing fails
+ *
+ * @example
+ * ```typescript
+ * // GitHub HTTPS
+ * parseRepositoryUrl('https://github.com/owner/repo')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ *
+ * // SSH format
+ * parseRepositoryUrl('git@github.com:owner/repo.git')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ *
+ * // Azure DevOps
+ * parseRepositoryUrl('https://dev.azure.com/org/proj/_git/repo')
+ * // → { platform: 'azure-devops', baseUrl: 'https://dev.azure.com/org/proj/_git/repo' }
+ *
+ * // Self-hosted GitLab
+ * parseRepositoryUrl('https://gitlab.mycompany.com/team/project')
+ * // → { platform: 'gitlab', baseUrl: 'https://gitlab.mycompany.com/team/project' }
+ * ```
+ */
+function parseRepositoryUrl(gitUrl) {
+    if (!gitUrl || typeof gitUrl !== 'string') {
+        return null;
+    }
+    const trimmed = gitUrl.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // Try SSH format first: git@hostname:path
+    const sshParsed = parseSshUrl(trimmed);
+    if (sshParsed) {
+        return sshParsed;
+    }
+    // Try HTTP(S) formats
+    const httpParsed = parseHttpUrl(trimmed);
+    if (httpParsed) {
+        return httpParsed;
+    }
+    return null;
+}
+/**
+ * Parses an SSH-style git URL.
+ *
+ * @param url - URL to parse (e.g., "git@github.com:owner/repo.git")
+ * @returns Parsed repository or null
+ *
+ * @internal
+ */
+function parseSshUrl(url) {
+    // Handle optional ssh:// prefix
+    let remaining = url;
+    if (remaining.startsWith('ssh://')) {
+        remaining = remaining.slice(6);
+    }
+    // Must start with git@
+    if (!remaining.startsWith('git@')) {
+        return null;
+    }
+    // Remove git@ prefix
+    remaining = remaining.slice(4);
+    // Find the separator (: or /)
+    const colonIndex = remaining.indexOf(':');
+    const slashIndex = remaining.indexOf('/');
+    let separatorIndex;
+    if (colonIndex === -1 && slashIndex === -1) {
+        return null;
+    }
+    else if (colonIndex === -1) {
+        separatorIndex = slashIndex;
+    }
+    else if (slashIndex === -1) {
+        separatorIndex = colonIndex;
+    }
+    else {
+        separatorIndex = min(colonIndex, slashIndex);
+    }
+    const hostname = remaining.slice(0, separatorIndex);
+    const pathPart = normalizePathPart(remaining.slice(separatorIndex + 1));
+    if (!hostname || !pathPart) {
+        return null;
+    }
+    const platform = detectPlatformFromHostname(hostname);
+    // For Azure DevOps, construct proper base URL
+    if (platform === 'azure-devops') {
+        const baseUrl = constructAzureDevOpsBaseUrl(hostname, pathPart);
+        if (baseUrl) {
+            return { platform, baseUrl };
+        }
+        return null;
+    }
+    // Standard platforms: https://hostname/path
+    const baseUrl = `https://${hostname}/${pathPart}`;
+    return { platform, baseUrl };
+}
+/**
+ * Parses an HTTP(S)-style git URL.
+ *
+ * @param url - URL to parse
+ * @returns Parsed repository or null
+ *
+ * @internal
+ */
+function parseHttpUrl(url) {
+    // Normalize various git URL prefixes to https://
+    const normalized = url
+        .replace(/^git\+/, '') // git+https:// → https://
+        .replace(/^git:\/\//, 'https://'); // git:// → https://
+    let parsed;
+    try {
+        parsed = createURL(normalized);
+    }
+    catch {
+        return null;
+    }
+    // Only support http and https protocols
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return null;
+    }
+    const hostname = parsed.hostname.toLowerCase();
+    const platform = detectPlatformFromHostname(hostname);
+    const pathPart = normalizePathPart(parsed.pathname);
+    if (!pathPart) {
+        return null;
+    }
+    // Handle Azure DevOps special URL structure
+    if (platform === 'azure-devops') {
+        const baseUrl = constructAzureDevOpsBaseUrl(hostname, pathPart);
+        if (baseUrl) {
+            return { platform, baseUrl };
+        }
+        // If Azure DevOps URL cannot be parsed properly, return null
+        return null;
+    }
+    // Standard platforms
+    const baseUrl = `${parsed.protocol}//${hostname}/${pathPart}`;
+    return { platform, baseUrl };
+}
+/**
+ * Normalizes a path part by removing leading slashes and .git suffix.
+ *
+ * @param path - Path to normalize
+ * @returns Normalized path or null if empty
+ *
+ * @internal
+ */
+function normalizePathPart(path) {
+    let normalized = path.trim();
+    // Remove leading slashes
+    while (normalized.startsWith('/')) {
+        normalized = normalized.slice(1);
+    }
+    // Remove trailing slashes
+    while (normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    // Remove .git suffix
+    if (normalized.endsWith('.git')) {
+        normalized = normalized.slice(0, -4);
+    }
+    // Validate we have something
+    if (!normalized) {
+        return null;
+    }
+    return normalized;
+}
+/**
+ * Constructs the base URL for Azure DevOps repositories.
+ *
+ * Azure DevOps has special URL structures:
+ * - Modern: `https://dev.azure.com/{org}/{project}/_git/{repo}`
+ * - Legacy: `https://{org}.visualstudio.com/{project}/_git/{repo}`
+ * - SSH: `git@ssh.dev.azure.com:v3/{org}/{project}/{repo}`
+ *
+ * @param hostname - Hostname from the URL
+ * @param pathPart - Path portion after hostname
+ * @returns Constructed base URL or null if invalid
+ *
+ * @internal
+ */
+function constructAzureDevOpsBaseUrl(hostname, pathPart) {
+    const pathParts = pathPart.split('/');
+    // dev.azure.com format: org/project/_git/repo
+    if (hostname === 'dev.azure.com' || hostname.endsWith('.azure.com')) {
+        // Need at least: org/project/_git/repo (4 parts)
+        // Or for SSH v3: v3/org/project/repo (4 parts)
+        if (pathParts.length >= 4) {
+            // Check for v3 SSH format
+            if (pathParts[0] === 'v3') {
+                // v3/org/project/repo → https://dev.azure.com/org/project/_git/repo
+                const org = pathParts[1];
+                const project = pathParts[2];
+                const repo = pathParts[3];
+                if (org && project && repo) {
+                    return `https://dev.azure.com/${org}/${project}/_git/${repo}`;
+                }
+            }
+            // Standard format: org/project/_git/repo
+            const gitIndex = pathParts.indexOf('_git');
+            if (gitIndex >= 2 && pathParts[gitIndex + 1]) {
+                const org = pathParts.slice(0, gitIndex - 1).join('/');
+                const project = pathParts[gitIndex - 1];
+                const repo = pathParts[gitIndex + 1];
+                if (org && project && repo) {
+                    return `https://dev.azure.com/${org}/${project}/_git/${repo}`;
+                }
+            }
+        }
+        return null;
+    }
+    // visualstudio.com format: {org}.visualstudio.com/project/_git/repo
+    if (hostname.endsWith('.visualstudio.com')) {
+        const org = hostname.replace('.visualstudio.com', '');
+        const gitIndex = pathParts.indexOf('_git');
+        if (gitIndex >= 1 && pathParts[gitIndex + 1]) {
+            const project = pathParts.slice(0, gitIndex).join('/');
+            const repo = pathParts[gitIndex + 1];
+            if (project && repo) {
+                // Normalize to dev.azure.com format
+                return `https://dev.azure.com/${org}/${project}/_git/${repo}`;
+            }
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * Creates a RepositoryConfig from a git URL.
+ *
+ * This is a convenience function that combines `parseRepositoryUrl` with
+ * `createRepositoryConfig` to produce a ready-to-use configuration.
+ *
+ * @param gitUrl - Git repository URL in any supported format
+ * @returns RepositoryConfig or null if URL cannot be parsed
+ *
+ * @example
+ * ```typescript
+ * const config = createRepositoryConfigFromUrl('https://github.com/owner/repo')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ *
+ * const config = createRepositoryConfigFromUrl('git@gitlab.com:group/project.git')
+ * // → { platform: 'gitlab', baseUrl: 'https://gitlab.com/group/project' }
+ * ```
+ */
+function createRepositoryConfigFromUrl(gitUrl) {
+    const parsed = parseRepositoryUrl(gitUrl);
+    if (!parsed) {
+        return null;
+    }
+    // Don't create configs for unknown platforms as they can't generate URLs
+    if (parsed.platform === 'unknown') {
+        return null;
+    }
+    return createRepositoryConfig({
+        platform: parsed.platform,
+        baseUrl: parsed.baseUrl,
+    });
+}
+
+/**
+ * Safe copies of JSON built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/json
+ */
+// Capture references at module initialization time
+const _JSON = globalThis.JSON;
+/**
+ * (Safe copy) Converts a JavaScript Object Notation (JSON) string into an object.
+ */
+const parse = _JSON.parse;
+
+/**
+ * Shorthand platform prefixes supported in package.json repository field.
+ *
+ * Format: `"platform:owner/repo"` or `"owner/repo"` (defaults to GitHub)
+ *
+ * @see https://docs.npmjs.com/cli/v9/configuring-npm/package-json#repository
+ */
+const SHORTHAND_PLATFORMS = createMap([
+    ['github', 'https://github.com'],
+    ['gitlab', 'https://gitlab.com'],
+    ['bitbucket', 'https://bitbucket.org'],
+    ['gist', 'https://gist.github.com'],
+]);
+/**
+ * Infers repository configuration from package.json content.
+ *
+ * Handles multiple formats:
+ * - Shorthand: `"github:owner/repo"`, `"gitlab:group/project"`, `"bitbucket:team/repo"`
+ * - Bare shorthand: `"owner/repo"` (defaults to GitHub)
+ * - URL string: `"https://github.com/owner/repo"`
+ * - Object with URL: `{ "type": "git", "url": "https://..." }`
+ *
+ * @param packageJsonContent - Raw JSON string content of package.json
+ * @returns RepositoryConfig or null if repository cannot be inferred
+ *
+ * @example
+ * ```typescript
+ * // Shorthand format
+ * inferRepositoryFromPackageJson('{"repository": "github:owner/repo"}')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ *
+ * // URL string
+ * inferRepositoryFromPackageJson('{"repository": "https://github.com/owner/repo"}')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ *
+ * // Object format
+ * inferRepositoryFromPackageJson('{"repository": {"type": "git", "url": "https://github.com/owner/repo"}}')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ *
+ * // Bare shorthand (defaults to GitHub)
+ * inferRepositoryFromPackageJson('{"repository": "owner/repo"}')
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ * ```
+ */
+function inferRepositoryFromPackageJson(packageJsonContent) {
+    if (!packageJsonContent || typeof packageJsonContent !== 'string') {
+        return null;
+    }
+    let packageJson;
+    try {
+        packageJson = parse(packageJsonContent);
+    }
+    catch {
+        return null;
+    }
+    return inferRepositoryFromPackageJsonObject(packageJson);
+}
+/**
+ * Infers repository configuration from a parsed package.json object.
+ *
+ * This is useful when you already have the parsed object.
+ *
+ * @param packageJson - Parsed package.json object
+ * @returns RepositoryConfig or null if repository cannot be inferred
+ *
+ * @example
+ * ```typescript
+ * const pkg = { repository: 'github:owner/repo' }
+ * inferRepositoryFromPackageJsonObject(pkg)
+ * // → { platform: 'github', baseUrl: 'https://github.com/owner/repo' }
+ * ```
+ */
+function inferRepositoryFromPackageJsonObject(packageJson) {
+    const { repository } = packageJson;
+    if (!repository) {
+        return null;
+    }
+    // Handle string format
+    if (typeof repository === 'string') {
+        return parseRepositoryString(repository);
+    }
+    // Handle object format
+    if (typeof repository === 'object' && repository.url) {
+        return createRepositoryConfigFromUrl(repository.url);
+    }
+    return null;
+}
+/**
+ * Parses a repository string (shorthand or URL).
+ *
+ * @param repoString - Repository string from package.json
+ * @returns RepositoryConfig or null
+ *
+ * @internal
+ */
+function parseRepositoryString(repoString) {
+    const trimmed = repoString.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // Check for shorthand format: platform:owner/repo
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0) {
+        const potentialPlatform = trimmed.slice(0, colonIndex);
+        // Platform must be only letters (a-z, case insensitive)
+        if (isOnlyLetters(potentialPlatform)) {
+            const platform = potentialPlatform.toLowerCase();
+            const path = trimmed.slice(colonIndex + 1);
+            if (path) {
+                const baseUrl = SHORTHAND_PLATFORMS.get(platform);
+                if (baseUrl) {
+                    // Construct full URL and parse it
+                    const fullUrl = `${baseUrl}/${path}`;
+                    return createRepositoryConfigFromUrl(fullUrl);
+                }
+                // Unknown shorthand platform - try as URL
+                return createRepositoryConfigFromUrl(trimmed);
+            }
+        }
+    }
+    // Check for bare shorthand: owner/repo (no protocol, no platform prefix)
+    // Must match pattern like "owner/repo" but not "https://..." or "git@..."
+    if (!trimmed.includes('://') && !trimmed.startsWith('git@')) {
+        if (isBareShorthand(trimmed)) {
+            // Bare shorthand defaults to GitHub
+            const fullUrl = `https://github.com/${trimmed}`;
+            return createRepositoryConfigFromUrl(fullUrl);
+        }
+    }
+    // Try as a full URL
+    return createRepositoryConfigFromUrl(trimmed);
+}
+/**
+ * Checks if a string contains only ASCII letters (a-z, A-Z).
+ *
+ * @param str - String to check
+ * @returns True if string contains only letters
+ *
+ * @internal
+ */
+function isOnlyLetters(str) {
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        const isLowercase = char >= 97 && char <= 122; // a-z
+        const isUppercase = char >= 65 && char <= 90; // A-Z
+        if (!isLowercase && !isUppercase) {
+            return false;
+        }
+    }
+    return str.length > 0;
+}
+/**
+ * Checks if a string is a bare shorthand format (owner/repo).
+ * Must have exactly one forward slash with content on both sides.
+ *
+ * @param str - String to check
+ * @returns True if string matches owner/repo format
+ *
+ * @internal
+ */
+function isBareShorthand(str) {
+    const slashIndex = str.indexOf('/');
+    if (slashIndex <= 0 || slashIndex === str.length - 1) {
+        return false;
+    }
+    // Must not have another slash
+    return str.indexOf('/', slashIndex + 1) === -1;
+}
+/**
+ * Extracts the repository URL from package.json content.
+ *
+ * Unlike `inferRepositoryFromPackageJson`, this returns just the URL string
+ * without creating a RepositoryConfig. Useful when you need the raw URL.
+ *
+ * @param packageJsonContent - Raw JSON string content of package.json
+ * @returns Repository URL string or null if not found
+ *
+ * @example
+ * ```typescript
+ * extractRepositoryUrl('{"repository": {"url": "https://github.com/owner/repo"}}')
+ * // → 'https://github.com/owner/repo'
+ *
+ * extractRepositoryUrl('{"repository": "github:owner/repo"}')
+ * // → null (shorthand is not a URL)
+ * ```
+ */
+function extractRepositoryUrl(packageJsonContent) {
+    if (!packageJsonContent || typeof packageJsonContent !== 'string') {
+        return null;
+    }
+    let packageJson;
+    try {
+        packageJson = parse(packageJsonContent);
+    }
+    catch {
+        return null;
+    }
+    const { repository } = packageJson;
+    if (!repository) {
+        return null;
+    }
+    // String URL format
+    if (typeof repository === 'string') {
+        // Check if it's a URL (has protocol)
+        if (repository.includes('://') || repository.startsWith('git@')) {
+            const parsed = parseRepositoryUrl(repository);
+            return parsed && parsed.platform !== 'unknown' ? parsed.baseUrl : null;
+        }
+        // Shorthand - need to expand
+        const config = parseRepositoryString(repository);
+        return config ? config.baseUrl : null;
+    }
+    // Object format
+    if (typeof repository === 'object' && repository.url) {
+        const parsed = parseRepositoryUrl(repository.url);
+        return parsed && parsed.platform !== 'unknown' ? parsed.baseUrl : null;
+    }
+    return null;
+}
+
+exports.createRepositoryConfigFromUrl = createRepositoryConfigFromUrl;
+exports.extractRepositoryUrl = extractRepositoryUrl;
+exports.inferRepositoryFromPackageJson = inferRepositoryFromPackageJson;
+exports.inferRepositoryFromPackageJsonObject = inferRepositoryFromPackageJsonObject;
+exports.parseRepositoryUrl = parseRepositoryUrl;
+//# sourceMappingURL=index.cjs.js.map