extension-from-store 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,91 +1,32 @@
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
-import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
-import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
-import * as __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__ from "extract-zip";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
-import * as __WEBPACK_EXTERNAL_MODULE_node_http_2dc67212__ from "node:http";
-import * as __WEBPACK_EXTERNAL_MODULE_node_https_626f33a7__ from "node:https";
-import * as __WEBPACK_EXTERNAL_MODULE_node_stream_promises_5adae1f2__ from "node:stream/promises";
-import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
-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}`);
-}
+import promises from "node:fs/promises";
+import node_os from "node:os";
+import node_path from "node:path";
+import extract_zip from "extract-zip";
+import node_fs from "node:fs";
+import node_http from "node:http";
+import node_https from "node:https";
+import { pipeline } from "node:stream/promises";
+import { URL } from "node:url";
+import { createLogger, stripCrxHeader, extensionFromStoreError as errors_extensionFromStoreError, resolveDownload, sanitizeSegment, validateInput, parseManifestInfo } from "./588.js";
 async function extractCrx(crxPath, extractDir, workDir) {
-    const crxBuffer = await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(crxPath);
+    const crxBuffer = await promises.readFile(crxPath);
     const zipBuffer = Buffer.from(stripCrxHeader(crxBuffer));
-    const zipPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(workDir, 'payload.zip');
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(zipPath, zipBuffer);
-    await (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["default"])(zipPath, {
+    const zipPath = node_path.join(workDir, 'payload.zip');
+    await promises.writeFile(zipPath, zipBuffer);
+    await extract_zip(zipPath, {
         dir: extractDir
     });
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].unlink(zipPath).catch(()=>void 0);
+    await promises.unlink(zipPath).catch(()=>void 0);
 }
 async function extractZipArchive(zipPath, extractDir) {
-    await (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["default"])(zipPath, {
+    await extract_zip(zipPath, {
         dir: extractDir
     });
 }
-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);
-        }
-    };
-}
 const DEFAULT_USER_AGENT = 'extension-from-store';
 function request(url, options) {
-    const target = new __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__.URL(url);
-    const client = 'http:' === target.protocol ? __WEBPACK_EXTERNAL_MODULE_node_http_2dc67212__["default"] : __WEBPACK_EXTERNAL_MODULE_node_https_626f33a7__["default"];
+    const target = new URL(url);
+    const client = 'http:' === target.protocol ? node_http : node_https;
     const headers = {
         'user-agent': options.userAgent || DEFAULT_USER_AGENT
     };
@@ -110,7 +51,7 @@ function request(url, options) {
     });
 }
 function resolveRedirectUrl(base, location) {
-    return new __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__.URL(location, base).toString();
+    return new URL(location, base).toString();
 }
 async function downloadToFile(url, filePath, options, maxRedirects = 5) {
     const log = createLogger(options.logger);
@@ -126,7 +67,7 @@ async function downloadToFile(url, filePath, options, maxRedirects = 5) {
         if (401 === statusCode || 403 === statusCode) throw new errors_extensionFromStoreError('NotPublic', 'Extension is not publicly downloadable');
         throw new errors_extensionFromStoreError('DownloadFailed', `Failed to download ${url} (HTTP ${statusCode})`);
     }
-    await (0, __WEBPACK_EXTERNAL_MODULE_node_stream_promises_5adae1f2__.pipeline)(stream, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].createWriteStream(filePath));
+    await pipeline(stream, node_fs.createWriteStream(filePath));
 }
 async function requestJson(url, options, maxRedirects = 5) {
     const { statusCode, headers, stream } = await request(url, options);
@@ -148,29 +89,10 @@ async function requestJson(url, options, maxRedirects = 5) {
         throw new errors_extensionFromStoreError('StoreIncompatibility', `Invalid JSON response from ${url}`, 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
-    };
-}
 async function readManifestInfo(manifestPath) {
     let raw = '';
     try {
-        raw = await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].readFile(manifestPath, 'utf8');
+        raw = await promises.readFile(manifestPath, 'utf8');
     } catch (error) {
         throw new errors_extensionFromStoreError('ExtractionFailed', 'manifest.json was not found after extraction', error);
     }
@@ -187,155 +109,17 @@ function getNodeChromePlatformInfo() {
         arch: getNodeArch()
     };
 }
-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');
-}
-function sanitizeSegment(value, label) {
-    const sanitized = value.replace(/[\\/]/g, '-').trim();
-    if (!sanitized) throw new errors_extensionFromStoreError('InvalidInput', `${label} is not a valid path segment`);
-    return sanitized;
-}
-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
-    };
-}
 function defaultOutputDir() {
-    return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(process.cwd(), 'extensions');
+    return node_path.resolve(process.cwd(), 'extensions');
 }
 async function ensureDirExists(dir) {
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(dir, {
+    await promises.mkdir(dir, {
         recursive: true
     });
 }
 async function pathExists(target) {
     try {
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(target);
+        await promises.access(target);
         return true;
     } catch  {
         return false;
@@ -343,12 +127,12 @@ async function pathExists(target) {
 }
 async function moveDir(source, destination) {
     try {
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rename(source, destination);
+        await promises.rename(source, destination);
     } catch  {
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].cp(source, destination, {
+        await promises.cp(source, destination, {
             recursive: true
         });
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rm(source, {
+        await promises.rm(source, {
             recursive: true,
             force: true
         });
@@ -360,7 +144,7 @@ function errorWithCode(code, message, cause) {
 async function fetchExtensionFromStore(url, options = {}) {
     validateInput(url);
     const log = createLogger(options.logger);
-    const outDir = options.outDir ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(options.outDir) : defaultOutputDir();
+    const outDir = options.outDir ? node_path.resolve(options.outDir) : defaultOutputDir();
     await ensureDirExists(outDir);
     const resolved = await resolveDownload(url, {
         version: options.version,
@@ -370,9 +154,9 @@ async function fetchExtensionFromStore(url, options = {}) {
         requestJson: requestJson
     });
     if (options.version && !url.includes('addons.mozilla.org')) log.warn('Version hints are best-effort and only supported on Firefox at the moment.');
-    const workDir = await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdtemp(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(__WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].tmpdir(), 'extension-from-store-'));
-    const archivePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(workDir, `archive.${resolved.archiveType}`);
-    const extractDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(workDir, 'extracted');
+    const workDir = await promises.mkdtemp(node_path.join(node_os.tmpdir(), 'extension-from-store-'));
+    const archivePath = node_path.join(workDir, `archive.${resolved.archiveType}`);
+    const extractDir = node_path.join(workDir, 'extracted');
     try {
         log.info(`Downloading from ${resolved.downloadUrl}`);
         await downloadToFile(resolved.downloadUrl, archivePath, {
@@ -383,40 +167,41 @@ async function fetchExtensionFromStore(url, options = {}) {
         const versionSuffix = resolved.versionHint ? `@${sanitizeSegment(resolved.versionHint, 'Extension version')}` : '';
         if (true !== options.extract) {
             const archiveName = `${safeId}${versionSuffix}.${resolved.archiveType}`;
-            const finalArchivePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(outDir, archiveName);
+            const finalArchivePath = node_path.join(outDir, archiveName);
             if (await pathExists(finalArchivePath)) throw errorWithCode('FilesystemConflict', `Target file already exists: ${finalArchivePath}`);
-            await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rename(archivePath, finalArchivePath);
+            await promises.rename(archivePath, finalArchivePath);
             return;
         }
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(extractDir, {
+        await promises.mkdir(extractDir, {
             recursive: true
         });
         if ('crx' === resolved.archiveType) await extractCrx(archivePath, extractDir, workDir);
         else await extractZipArchive(archivePath, extractDir);
-        const manifestPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(extractDir, 'manifest.json');
+        const manifestPath = node_path.join(extractDir, 'manifest.json');
         const manifestInfo = await readManifestInfo(manifestPath);
         const resolvedVersion = resolved.versionHint || manifestInfo.extensionVersion;
         const safeVersion = sanitizeSegment(resolvedVersion, 'Extension version');
         const folderName = `${safeId}@${safeVersion}`;
-        const finalDir = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(outDir, folderName);
+        const finalDir = node_path.join(outDir, folderName);
         if (await pathExists(finalDir)) throw errorWithCode('FilesystemConflict', `Target folder already exists: ${finalDir}`);
         await moveDir(extractDir, finalDir);
-        const metaPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(finalDir, 'extension.meta.json');
+        const metaPath = node_path.join(finalDir, 'extension.meta.json');
         const meta = {
             store: resolved.store,
             identifier: resolved.slugOrId,
             version: resolvedVersion,
             manifestVersion: manifestInfo.manifestVersion
         };
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(metaPath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+        await promises.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
     } catch (error) {
         if (error instanceof errors_extensionFromStoreError) throw error;
         throw errorWithCode('ExtractionFailed', 'Failed to extract extension', error);
     } finally{
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].rm(workDir, {
+        await promises.rm(workDir, {
             recursive: true,
             force: true
         }).catch(()=>void 0);
     }
 }
-export { errors_extensionFromStoreError as extensionFromStoreError, fetchExtensionFromStore };
+export { extensionFromStoreError } from "./588.js";
+export { fetchExtensionFromStore };

package/package.json

@@ -9,7 +9,7 @@
   },
   "engineStrict": false,
   "name": "extension-from-store",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Download public browser extensions from official stores",
   "homepage": "https://www.npmjs.com/package/extension-from-store",
   "type": "module",
@@ -80,7 +80,7 @@
   ],
   "dependencies": {
     "extract-zip": "^2.0.1",
-    "fflate": "^0.8.2"
+    "fflate": "^0.8.3"
   },
   "pnpm": {
     "overrides": {
@@ -97,12 +97,12 @@
     }
   },
   "devDependencies": {
-    "@rslib/core": "^0.6.9",
-    "@types/node": "^22.8.1",
+    "@rslib/core": "^0.23.0",
+    "@types/node": "^25.9.3",
     "eslint": "^10.5.0",
-    "eslint-config-auditor": "^2.0.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
+    "eslint-config-auditor": "^2.3.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
   },
   "packageManager": "pnpm@9.9.0+sha512.60c18acd138bff695d339be6ad13f7e936eea6745660d4cc4a776d5247c540d0edee1a563695c183a66eb917ef88f2b4feb1fc25f32a7adcadc7aaf3438e99c1",
   "bugs": "https://github.com/cezaraugusto/extension-from-store/issues",