extension-from-store 0.1.1 → 0.2.0

package/dist/browser.js

@@ -0,0 +1,321 @@
+import * as __WEBPACK_EXTERNAL_MODULE_fflate__ from "fflate";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class errors_extensionFromStoreError extends Error {
+    constructor(code, message, cause){
+        super(message), _define_property(this, "code", void 0), _define_property(this, "cause", void 0);
+        this.code = code;
+        this.cause = cause;
+    }
+}
+function readUInt32LE(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, Uint32Array.BYTES_PER_ELEMENT);
+    return view.getUint32(0, true);
+}
+function readMagic(bytes) {
+    let out = '';
+    const slice = bytes.subarray(0, 4);
+    for(let index = 0; index < slice.length; index += 1)out += String.fromCharCode(slice[index]);
+    return out;
+}
+function stripCrxHeader(buffer) {
+    if (buffer.length < 16) throw new errors_extensionFromStoreError('ExtractionFailed', 'CRX file too small');
+    const magic = readMagic(buffer);
+    if ('Cr24' !== magic) throw new errors_extensionFromStoreError('ExtractionFailed', 'Invalid CRX header');
+    const version = readUInt32LE(buffer, 4);
+    if (2 === version) {
+        const publicKeyLength = readUInt32LE(buffer, 8);
+        const signatureLength = readUInt32LE(buffer, 12);
+        const headerSize = 16 + publicKeyLength + signatureLength;
+        return buffer.subarray(headerSize);
+    }
+    if (3 === version) {
+        const headerSize = readUInt32LE(buffer, 8);
+        return buffer.subarray(12 + headerSize);
+    }
+    throw new errors_extensionFromStoreError('ExtractionFailed', `Unsupported CRX version ${version}`);
+}
+function createLogger(logger) {
+    return {
+        info: (message)=>{
+            var _logger_onInfo;
+            return null == logger ? void 0 : null == (_logger_onInfo = logger.onInfo) ? void 0 : _logger_onInfo.call(logger, message);
+        },
+        warn: (message)=>{
+            var _logger_onWarn;
+            return null == logger ? void 0 : null == (_logger_onWarn = logger.onWarn) ? void 0 : _logger_onWarn.call(logger, message);
+        },
+        error: (message, error)=>{
+            var _logger_onError;
+            return null == logger ? void 0 : null == (_logger_onError = logger.onError) ? void 0 : _logger_onError.call(logger, message, error);
+        }
+    };
+}
+function parseManifestInfo(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json is not valid JSON', error);
+    }
+    if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json must contain an object');
+    const manifest = parsed;
+    const manifestVersion = manifest.manifest_version;
+    const extensionVersion = manifest.version;
+    if (2 !== manifestVersion && 3 !== manifestVersion) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest_version must be 2 or 3');
+    if (!extensionVersion || 'string' != typeof extensionVersion) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json is missing a version');
+    return {
+        manifest,
+        manifestVersion,
+        extensionVersion
+    };
+}
+function normalizeChromePlatformInfo(platform) {
+    return {
+        os: platform.os,
+        arch: platform.arch,
+        naclArch: platform.naclArch || platform.arch
+    };
+}
+const DEFAULT_CHROME_PLATFORM = {
+    os: 'linux',
+    arch: 'x64'
+};
+function getChromeDownloadUrl(id, platformInfo = DEFAULT_CHROME_PLATFORM) {
+    const encoded = encodeURIComponent(id);
+    const platform = normalizeChromePlatformInfo(platformInfo);
+    const productId = 'chromiumcrx';
+    const productChannel = 'unknown';
+    const productVersion = '9999.0.9999.0';
+    return [
+        'https://clients2.google.com/service/update2/crx',
+        '?response=redirect',
+        `&os=${platform.os}`,
+        `&arch=${platform.arch}`,
+        `&os_arch=${platform.arch}`,
+        `&nacl_arch=${platform.naclArch}`,
+        `&prod=${productId}`,
+        `&prodchannel=${productChannel}`,
+        `&prodversion=${productVersion}`,
+        '&acceptformat=crx2,crx3',
+        `&x=id%3D${encoded}%26uc`
+    ].join('');
+}
+function getEdgeDownloadUrl(id) {
+    const encoded = encodeURIComponent(id);
+    return [
+        'https://edge.microsoft.com/extensionwebstorebase/v1/crx',
+        '?response=redirect',
+        '&prodversion=109.0.0.0',
+        `&x=id%3D${encoded}%26installsource%3Dondemand%26uc`
+    ].join('');
+}
+async function resolveFirefoxDownload(idOrSlug, versionHint, options) {
+    var _addon_current_version_file, _addon_current_version, _addon_current_version1;
+    const baseUrl = `https://addons.mozilla.org/api/v5/addons/addon/${encodeURIComponent(idOrSlug)}/`;
+    const addon = await options.requestJson(baseUrl, options);
+    const slugOrId = addon.slug || idOrSlug;
+    if (versionHint) {
+        var _version_file;
+        const versionUrl = `${baseUrl}versions/${encodeURIComponent(versionHint)}/`;
+        const version = await options.requestJson(versionUrl, options);
+        const downloadUrl = null == (_version_file = version.file) ? void 0 : _version_file.url;
+        if (!downloadUrl) throw new errors_extensionFromStoreError('NotPublic', `Version ${versionHint} is not publicly downloadable`);
+        return {
+            downloadUrl,
+            version: version.version || versionHint,
+            slugOrId
+        };
+    }
+    const downloadUrl = null == (_addon_current_version = addon.current_version) ? void 0 : null == (_addon_current_version_file = _addon_current_version.file) ? void 0 : _addon_current_version_file.url;
+    const version = null == (_addon_current_version1 = addon.current_version) ? void 0 : _addon_current_version1.version;
+    if (!downloadUrl || !version) throw new errors_extensionFromStoreError('NotPublic', 'Extension is not publicly downloadable');
+    return {
+        downloadUrl,
+        version,
+        slugOrId
+    };
+}
+const chromePattern = /^https?:\/\/(?:chrome\.google\.com\/webstore|chromewebstore\.google\.com)\/.+?\/([a-p]{32})(?=[\/#?]|$)/i;
+const chromeDownloadPattern = /^https?:\/\/clients2\.google\.com\/service\/update2\/crx\b.*?%3D([a-p]{32})%26uc/i;
+const edgePattern = /^https?:\/\/microsoftedge\.microsoft\.com\/addons\/.+?\/([a-z]{32})(?=[\/#?]|$)/i;
+const edgeDownloadPattern = /^https?:\/\/edge\.microsoft\.com\/extensionwebstorebase\/v1\/crx\b.*?%3D([a-z]{32})%26/i;
+const firefoxPattern = /^https?:\/\/((?:reviewers\.)?(?:addons\.mozilla\.org|addons(?:-dev)?\.allizom\.org))\/.*?(?:addon|review)\/([^/<>"'?#]+)/i;
+const firefoxDownloadPattern = /^https?:\/\/(addons\.mozilla\.org|addons(?:-dev)?\.allizom\.org)\/[^?#]*\/downloads\/latest\/([^/?#]+)/i;
+function detectStoreFromUrl(url) {
+    if (chromePattern.test(url) || chromeDownloadPattern.test(url)) return 'chrome';
+    if (edgePattern.test(url) || edgeDownloadPattern.test(url)) return 'edge';
+    if (firefoxPattern.test(url) || firefoxDownloadPattern.test(url)) return 'firefox';
+    return null;
+}
+function extractChromeIdFromUrl(url) {
+    const match = chromePattern.exec(url) || chromeDownloadPattern.exec(url);
+    return match ? match[1] : null;
+}
+function extractEdgeIdFromUrl(url) {
+    const match = edgePattern.exec(url) || edgeDownloadPattern.exec(url);
+    return match ? match[1] : null;
+}
+function extractFirefoxSlugFromUrl(url) {
+    const match = firefoxPattern.exec(url) || firefoxDownloadPattern.exec(url);
+    return match ? match[2] : null;
+}
+function validateInput(url) {
+    if (!url || 'string' != typeof url) throw new errors_extensionFromStoreError('InvalidInput', 'URL is required');
+}
+async function resolveDownload(url, options) {
+    const store = detectStoreFromUrl(url);
+    if (!store) throw new errors_extensionFromStoreError('UnsupportedStore', 'URL does not match a supported store');
+    if ('chrome' === store) {
+        const downloadId = extractChromeIdFromUrl(url);
+        if (!downloadId) throw new errors_extensionFromStoreError('NotFound', 'Chrome extension id not found in URL');
+        return {
+            store,
+            downloadUrl: getChromeDownloadUrl(downloadId, options.platform),
+            archiveType: 'crx',
+            downloadId,
+            slugOrId: downloadId
+        };
+    }
+    if ('edge' === store) {
+        const downloadId = extractEdgeIdFromUrl(url);
+        if (!downloadId) throw new errors_extensionFromStoreError('NotFound', 'Edge extension id not found in URL');
+        return {
+            store,
+            downloadUrl: getEdgeDownloadUrl(downloadId),
+            archiveType: 'crx',
+            downloadId,
+            slugOrId: downloadId
+        };
+    }
+    const slug = extractFirefoxSlugFromUrl(url);
+    if (!slug) throw new errors_extensionFromStoreError('NotFound', 'Firefox extension slug not found in URL');
+    const firefox = await resolveFirefoxDownload(slug, options.version, {
+        userAgent: options.userAgent,
+        logger: options.logger,
+        requestJson: options.requestJson
+    });
+    return {
+        store,
+        downloadUrl: firefox.downloadUrl,
+        archiveType: 'xpi',
+        versionHint: firefox.version,
+        slugOrId: firefox.slugOrId
+    };
+}
+const TEXT_FILE_PATTERN = /(^|\/)(?:[^/]+\.(?:txt|md|mdx|json|js|jsx|mjs|cjs|ts|tsx|css|scss|sass|less|html|xml|svg|yml|yaml|toml|ini|conf|map)|\.(?:gitignore|npmrc|editorconfig|prettierrc|eslintrc))$/i;
+function getDefaultFetch() {
+    if ('function' != typeof globalThis.fetch) throw new errors_extensionFromStoreError('DownloadFailed', 'No fetch implementation was provided');
+    return globalThis.fetch.bind(globalThis);
+}
+function inferBrowserChromePlatformInfo() {
+    var _navigatorLike_userAgentData;
+    const navigatorLike = globalThis.navigator;
+    const fingerprint = [
+        null == navigatorLike ? void 0 : navigatorLike.platform,
+        null == navigatorLike ? void 0 : navigatorLike.userAgent,
+        null == navigatorLike ? void 0 : null == (_navigatorLike_userAgentData = navigatorLike.userAgentData) ? void 0 : _navigatorLike_userAgentData.platform
+    ].filter(Boolean).join(' ').toLowerCase();
+    const os = fingerprint.includes('mac') ? 'mac' : fingerprint.includes('win') ? 'win' : 'linux';
+    const arch = fingerprint.includes('arm') || fingerprint.includes('aarch64') ? 'arm64' : fingerprint.includes('i686') || fingerprint.includes('i386') || fingerprint.includes('x86') && !fingerprint.includes('x86_64') ? 'x86' : 'x64';
+    return {
+        os,
+        arch
+    };
+}
+function isLikelyTextFile(path) {
+    return 'manifest.json' === path || TEXT_FILE_PATTERN.test(path);
+}
+function decodeText(bytes) {
+    return (0, __WEBPACK_EXTERNAL_MODULE_fflate__.strFromU8)(bytes);
+}
+function mapHttpError(url, status) {
+    if (404 === status) return new errors_extensionFromStoreError('NotFound', `Extension not found at ${url}`);
+    if (401 === status || 403 === status) return new errors_extensionFromStoreError('NotPublic', 'Extension is not publicly downloadable');
+    return new errors_extensionFromStoreError('DownloadFailed', `Failed to request ${url} (HTTP ${status})`);
+}
+async function requestJsonWithFetch(url, options) {
+    if (options.userAgent) createLogger(options.logger).warn('Custom user agents are ignored in browser environments.');
+    const response = await options.fetchImpl(url);
+    if (!response.ok) throw mapHttpError(url, response.status);
+    const body = await response.text();
+    try {
+        return JSON.parse(body);
+    } catch (error) {
+        throw new errors_extensionFromStoreError('StoreIncompatibility', `Invalid JSON response from ${url}`, error);
+    }
+}
+async function downloadBytes(url, options) {
+    if (options.userAgent) createLogger(options.logger).warn('Custom user agents are ignored in browser environments.');
+    const response = await options.fetchImpl(url);
+    if (!response.ok) throw mapHttpError(url, response.status);
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    return {
+        finalUrl: response.url || url,
+        bytes
+    };
+}
+function buildBrowserFiles(entries) {
+    return Object.entries(entries).sort(([left], [right])=>left.localeCompare(right)).map(([path, bytes])=>({
+            path,
+            bytes,
+            text: isLikelyTextFile(path) ? decodeText(bytes) : void 0
+        }));
+}
+async function fetchExtensionFromStoreBrowser(url, options = {}) {
+    validateInput(url);
+    const fetchImpl = options.fetch || getDefaultFetch();
+    const resolved = await resolveDownload(url, {
+        version: options.version,
+        userAgent: options.userAgent,
+        logger: options.logger,
+        platform: options.platform || inferBrowserChromePlatformInfo(),
+        requestJson: (requestUrl, requestOptions)=>requestJsonWithFetch(requestUrl, {
+                ...requestOptions,
+                fetchImpl
+            })
+    });
+    const archive = await downloadBytes(resolved.downloadUrl, {
+        fetchImpl,
+        userAgent: options.userAgent,
+        logger: options.logger
+    });
+    const zipPayload = 'crx' === resolved.archiveType ? stripCrxHeader(archive.bytes) : archive.bytes;
+    let filesByPath;
+    try {
+        filesByPath = (0, __WEBPACK_EXTERNAL_MODULE_fflate__.unzipSync)(zipPayload);
+    } catch (error) {
+        throw new errors_extensionFromStoreError('ExtractionFailed', 'Failed to extract extension archive', error);
+    }
+    const manifestBytes = filesByPath['manifest.json'];
+    if (!manifestBytes) throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json was not found after extraction');
+    const manifestInfo = parseManifestInfo(decodeText(manifestBytes));
+    const version = resolved.versionHint || manifestInfo.extensionVersion;
+    const files = buildBrowserFiles(filesByPath);
+    return {
+        store: resolved.store,
+        identifier: resolved.slugOrId,
+        version,
+        manifestVersion: manifestInfo.manifestVersion,
+        archiveType: resolved.archiveType,
+        downloadUrl: archive.finalUrl,
+        archiveBytes: archive.bytes,
+        manifest: manifestInfo.manifest,
+        files,
+        meta: {
+            store: resolved.store,
+            identifier: resolved.slugOrId,
+            version,
+            manifestVersion: manifestInfo.manifestVersion
+        }
+    };
+}
+export { fetchExtensionFromStoreBrowser };

package/dist/core.cjs

@@ -0,0 +1,301 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    extractEdgeIdFromUrl: ()=>extractEdgeIdFromUrl,
+    detectStoreFromUrl: ()=>detectStoreFromUrl,
+    extractChromeIdFromUrl: ()=>extractChromeIdFromUrl,
+    createLogger: ()=>createLogger,
+    stripCrxHeader: ()=>stripCrxHeader,
+    sanitizeSegment: ()=>sanitizeSegment,
+    getChromeDownloadUrl: ()=>getChromeDownloadUrl,
+    asExtensionFromStoreError: ()=>asExtensionFromStoreError,
+    extractFirefoxSlugFromUrl: ()=>extractFirefoxSlugFromUrl,
+    resolveFirefoxDownload: ()=>resolveFirefoxDownload,
+    validateInput: ()=>validateInput,
+    getEdgeDownloadUrl: ()=>getEdgeDownloadUrl,
+    resolveDownload: ()=>resolveDownload,
+    extensionFromStoreError: ()=>extensionFromStoreError,
+    parseManifestInfo: ()=>parseManifestInfo,
+    normalizeChromePlatformInfo: ()=>normalizeChromePlatformInfo
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class extensionFromStoreError extends Error {
+    constructor(code, message, cause){
+        super(message), _define_property(this, "code", void 0), _define_property(this, "cause", void 0);
+        this.code = code;
+        this.cause = cause;
+    }
+}
+function asExtensionFromStoreError(error, fallback) {
+    if (error instanceof extensionFromStoreError) return error;
+    return new extensionFromStoreError(fallback.code, fallback.message, error);
+}
+function createLogger(logger) {
+    return {
+        info: (message)=>{
+            var _logger_onInfo;
+            return null == logger ? void 0 : null == (_logger_onInfo = logger.onInfo) ? void 0 : _logger_onInfo.call(logger, message);
+        },
+        warn: (message)=>{
+            var _logger_onWarn;
+            return null == logger ? void 0 : null == (_logger_onWarn = logger.onWarn) ? void 0 : _logger_onWarn.call(logger, message);
+        },
+        error: (message, error)=>{
+            var _logger_onError;
+            return null == logger ? void 0 : null == (_logger_onError = logger.onError) ? void 0 : _logger_onError.call(logger, message, error);
+        }
+    };
+}
+function parseManifestInfo(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (error) {
+        throw new extensionFromStoreError('ExtractionFailed', 'manifest.json is not valid JSON', error);
+    }
+    if (!parsed || 'object' != typeof parsed || Array.isArray(parsed)) throw new extensionFromStoreError('ExtractionFailed', 'manifest.json must contain an object');
+    const manifest = parsed;
+    const manifestVersion = manifest.manifest_version;
+    const extensionVersion = manifest.version;
+    if (2 !== manifestVersion && 3 !== manifestVersion) throw new extensionFromStoreError('ExtractionFailed', 'manifest_version must be 2 or 3');
+    if (!extensionVersion || 'string' != typeof extensionVersion) throw new extensionFromStoreError('ExtractionFailed', 'manifest.json is missing a version');
+    return {
+        manifest,
+        manifestVersion,
+        extensionVersion
+    };
+}
+function normalizeChromePlatformInfo(platform) {
+    return {
+        os: platform.os,
+        arch: platform.arch,
+        naclArch: platform.naclArch || platform.arch
+    };
+}
+const DEFAULT_CHROME_PLATFORM = {
+    os: 'linux',
+    arch: 'x64'
+};
+function getChromeDownloadUrl(id, platformInfo = DEFAULT_CHROME_PLATFORM) {
+    const encoded = encodeURIComponent(id);
+    const platform = normalizeChromePlatformInfo(platformInfo);
+    const productId = 'chromiumcrx';
+    const productChannel = 'unknown';
+    const productVersion = '9999.0.9999.0';
+    return [
+        'https://clients2.google.com/service/update2/crx',
+        '?response=redirect',
+        `&os=${platform.os}`,
+        `&arch=${platform.arch}`,
+        `&os_arch=${platform.arch}`,
+        `&nacl_arch=${platform.naclArch}`,
+        `&prod=${productId}`,
+        `&prodchannel=${productChannel}`,
+        `&prodversion=${productVersion}`,
+        '&acceptformat=crx2,crx3',
+        `&x=id%3D${encoded}%26uc`
+    ].join('');
+}
+function getEdgeDownloadUrl(id) {
+    const encoded = encodeURIComponent(id);
+    return [
+        'https://edge.microsoft.com/extensionwebstorebase/v1/crx',
+        '?response=redirect',
+        '&prodversion=109.0.0.0',
+        `&x=id%3D${encoded}%26installsource%3Dondemand%26uc`
+    ].join('');
+}
+async function resolveFirefoxDownload(idOrSlug, versionHint, options) {
+    var _addon_current_version_file, _addon_current_version, _addon_current_version1;
+    const baseUrl = `https://addons.mozilla.org/api/v5/addons/addon/${encodeURIComponent(idOrSlug)}/`;
+    const addon = await options.requestJson(baseUrl, options);
+    const slugOrId = addon.slug || idOrSlug;
+    if (versionHint) {
+        var _version_file;
+        const versionUrl = `${baseUrl}versions/${encodeURIComponent(versionHint)}/`;
+        const version = await options.requestJson(versionUrl, options);
+        const downloadUrl = null == (_version_file = version.file) ? void 0 : _version_file.url;
+        if (!downloadUrl) throw new extensionFromStoreError('NotPublic', `Version ${versionHint} is not publicly downloadable`);
+        return {
+            downloadUrl,
+            version: version.version || versionHint,
+            slugOrId
+        };
+    }
+    const downloadUrl = null == (_addon_current_version = addon.current_version) ? void 0 : null == (_addon_current_version_file = _addon_current_version.file) ? void 0 : _addon_current_version_file.url;
+    const version = null == (_addon_current_version1 = addon.current_version) ? void 0 : _addon_current_version1.version;
+    if (!downloadUrl || !version) throw new extensionFromStoreError('NotPublic', 'Extension is not publicly downloadable');
+    return {
+        downloadUrl,
+        version,
+        slugOrId
+    };
+}
+const chromePattern = /^https?:\/\/(?:chrome\.google\.com\/webstore|chromewebstore\.google\.com)\/.+?\/([a-p]{32})(?=[\/#?]|$)/i;
+const chromeDownloadPattern = /^https?:\/\/clients2\.google\.com\/service\/update2\/crx\b.*?%3D([a-p]{32})%26uc/i;
+const edgePattern = /^https?:\/\/microsoftedge\.microsoft\.com\/addons\/.+?\/([a-z]{32})(?=[\/#?]|$)/i;
+const edgeDownloadPattern = /^https?:\/\/edge\.microsoft\.com\/extensionwebstorebase\/v1\/crx\b.*?%3D([a-z]{32})%26/i;
+const firefoxPattern = /^https?:\/\/((?:reviewers\.)?(?:addons\.mozilla\.org|addons(?:-dev)?\.allizom\.org))\/.*?(?:addon|review)\/([^/<>"'?#]+)/i;
+const firefoxDownloadPattern = /^https?:\/\/(addons\.mozilla\.org|addons(?:-dev)?\.allizom\.org)\/[^?#]*\/downloads\/latest\/([^/?#]+)/i;
+function detectStoreFromUrl(url) {
+    if (chromePattern.test(url) || chromeDownloadPattern.test(url)) return 'chrome';
+    if (edgePattern.test(url) || edgeDownloadPattern.test(url)) return 'edge';
+    if (firefoxPattern.test(url) || firefoxDownloadPattern.test(url)) return 'firefox';
+    return null;
+}
+function extractChromeIdFromUrl(url) {
+    const match = chromePattern.exec(url) || chromeDownloadPattern.exec(url);
+    return match ? match[1] : null;
+}
+function extractEdgeIdFromUrl(url) {
+    const match = edgePattern.exec(url) || edgeDownloadPattern.exec(url);
+    return match ? match[1] : null;
+}
+function extractFirefoxSlugFromUrl(url) {
+    const match = firefoxPattern.exec(url) || firefoxDownloadPattern.exec(url);
+    return match ? match[2] : null;
+}
+function validateInput(url) {
+    if (!url || 'string' != typeof url) throw new extensionFromStoreError('InvalidInput', 'URL is required');
+}
+function sanitizeSegment(value, label) {
+    const sanitized = value.replace(/[\\/]/g, '-').trim();
+    if (!sanitized) throw new extensionFromStoreError('InvalidInput', `${label} is not a valid path segment`);
+    return sanitized;
+}
+async function resolveDownload(url, options) {
+    const store = detectStoreFromUrl(url);
+    if (!store) throw new extensionFromStoreError('UnsupportedStore', 'URL does not match a supported store');
+    if ('chrome' === store) {
+        const downloadId = extractChromeIdFromUrl(url);
+        if (!downloadId) throw new extensionFromStoreError('NotFound', 'Chrome extension id not found in URL');
+        return {
+            store,
+            downloadUrl: getChromeDownloadUrl(downloadId, options.platform),
+            archiveType: 'crx',
+            downloadId,
+            slugOrId: downloadId
+        };
+    }
+    if ('edge' === store) {
+        const downloadId = extractEdgeIdFromUrl(url);
+        if (!downloadId) throw new extensionFromStoreError('NotFound', 'Edge extension id not found in URL');
+        return {
+            store,
+            downloadUrl: getEdgeDownloadUrl(downloadId),
+            archiveType: 'crx',
+            downloadId,
+            slugOrId: downloadId
+        };
+    }
+    const slug = extractFirefoxSlugFromUrl(url);
+    if (!slug) throw new extensionFromStoreError('NotFound', 'Firefox extension slug not found in URL');
+    const firefox = await resolveFirefoxDownload(slug, options.version, {
+        userAgent: options.userAgent,
+        logger: options.logger,
+        requestJson: options.requestJson
+    });
+    return {
+        store,
+        downloadUrl: firefox.downloadUrl,
+        archiveType: 'xpi',
+        versionHint: firefox.version,
+        slugOrId: firefox.slugOrId
+    };
+}
+function readUInt32LE(bytes, offset) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, Uint32Array.BYTES_PER_ELEMENT);
+    return view.getUint32(0, true);
+}
+function readMagic(bytes) {
+    let out = '';
+    const slice = bytes.subarray(0, 4);
+    for(let index = 0; index < slice.length; index += 1)out += String.fromCharCode(slice[index]);
+    return out;
+}
+function stripCrxHeader(buffer) {
+    if (buffer.length < 16) throw new extensionFromStoreError('ExtractionFailed', 'CRX file too small');
+    const magic = readMagic(buffer);
+    if ('Cr24' !== magic) throw new extensionFromStoreError('ExtractionFailed', 'Invalid CRX header');
+    const version = readUInt32LE(buffer, 4);
+    if (2 === version) {
+        const publicKeyLength = readUInt32LE(buffer, 8);
+        const signatureLength = readUInt32LE(buffer, 12);
+        const headerSize = 16 + publicKeyLength + signatureLength;
+        return buffer.subarray(headerSize);
+    }
+    if (3 === version) {
+        const headerSize = readUInt32LE(buffer, 8);
+        return buffer.subarray(12 + headerSize);
+    }
+    throw new extensionFromStoreError('ExtractionFailed', `Unsupported CRX version ${version}`);
+}
+exports.asExtensionFromStoreError = __webpack_exports__.asExtensionFromStoreError;
+exports.createLogger = __webpack_exports__.createLogger;
+exports.detectStoreFromUrl = __webpack_exports__.detectStoreFromUrl;
+exports.extensionFromStoreError = __webpack_exports__.extensionFromStoreError;
+exports.extractChromeIdFromUrl = __webpack_exports__.extractChromeIdFromUrl;
+exports.extractEdgeIdFromUrl = __webpack_exports__.extractEdgeIdFromUrl;
+exports.extractFirefoxSlugFromUrl = __webpack_exports__.extractFirefoxSlugFromUrl;
+exports.getChromeDownloadUrl = __webpack_exports__.getChromeDownloadUrl;
+exports.getEdgeDownloadUrl = __webpack_exports__.getEdgeDownloadUrl;
+exports.normalizeChromePlatformInfo = __webpack_exports__.normalizeChromePlatformInfo;
+exports.parseManifestInfo = __webpack_exports__.parseManifestInfo;
+exports.resolveDownload = __webpack_exports__.resolveDownload;
+exports.resolveFirefoxDownload = __webpack_exports__.resolveFirefoxDownload;
+exports.sanitizeSegment = __webpack_exports__.sanitizeSegment;
+exports.stripCrxHeader = __webpack_exports__.stripCrxHeader;
+exports.validateInput = __webpack_exports__.validateInput;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "asExtensionFromStoreError",
+    "createLogger",
+    "detectStoreFromUrl",
+    "extensionFromStoreError",
+    "extractChromeIdFromUrl",
+    "extractEdgeIdFromUrl",
+    "extractFirefoxSlugFromUrl",
+    "getChromeDownloadUrl",
+    "getEdgeDownloadUrl",
+    "normalizeChromePlatformInfo",
+    "parseManifestInfo",
+    "resolveDownload",
+    "resolveFirefoxDownload",
+    "sanitizeSegment",
+    "stripCrxHeader",
+    "validateInput"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/core.d.ts

@@ -0,0 +1,10 @@
+export { extensionFromStoreError, asExtensionFromStoreError, type ErrorCode, } from './errors';
+export { createLogger, type Logger } from './logger';
+export { parseManifestInfo, type ExtensionManifest, type ManifestInfo, } from './manifest';
+export { normalizeChromePlatformInfo, type ChromePlatformArch, type ChromePlatformInfo, type ChromePlatformOs, } from './platform';
+export { resolveDownload, sanitizeSegment, validateInput, type ResolveDownloadOptions, type ResolvedDownload, } from './resolve';
+export { stripCrxHeader } from './crx';
+export { getChromeDownloadUrl } from './stores/chrome';
+export { getEdgeDownloadUrl } from './stores/edge';
+export { resolveFirefoxDownload, type JsonRequester } from './stores/firefox';
+export { detectStoreFromUrl, extractChromeIdFromUrl, extractEdgeIdFromUrl, extractFirefoxSlugFromUrl, type StoreFromUrl, } from './stores/resolve-slug';