@ctrl/magnet-link 3.0.0 → 3.1.0

package/dist/src/bep53.d.ts

@@ -0,0 +1,2 @@
+export declare function composeRange(range: number[]): string[];
+export declare function parseRange(range: string[]): number[];

package/dist/src/bep53.js

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/restrict-plus-operands */
+export function composeRange(range) {
+    return range
+        .reduce((acc, cur, idx, arr) => {
+        // @ts-expect-error
+        if (idx === 0 || cur !== arr[idx - 1] + 1) {
+            acc.push([]);
+        }
+        // @ts-expect-error
+        acc[acc.length - 1].push(cur);
+        return acc;
+    }, [])
+        .map(cur => {
+        return cur.length > 1 ? `${cur[0]}-${cur[cur.length - 1]}` : `${cur[0]}`;
+    });
+}
+export function parseRange(range) {
+    const generateRange = (start, end = start) => Array.from({ length: end - start + 1 }, (_, idx) => idx + start);
+    return range.reduce((acc, cur) => {
+        const r = cur.split('-').map(cur => parseInt(cur, 10));
+        return acc.concat(generateRange(r[0], r[1]));
+    }, []);
+}

package/dist/src/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export interface MagnetData {
     /**
      * Is the info-hash hex encoded, for a total of 40 characters. For compatability with existing links in the wild, clients should also support the 32 character base32 encoded info-hash.
@@ -12,6 +13,9 @@ export interface MagnetData {
      * Parsed xt= parameter see xt
      */
     infoHash?: string;
+    infoHashBuffer?: Buffer;
+    infoHashV2?: string;
+    infoHashV2Buffer?: Buffer;
     /**
      * The display name that may be used by the client to display while waiting for metadata
      */
@@ -44,6 +48,8 @@ export interface MagnetData {
      * "keyword topic": a more general search, specifying search terms rather than a particular file
      */
     kt?: string[];
+    so?: string[] | number[];
+    'x.pe'?: string | string[];
     /**
      * "keyword topic": a more general search, specifying search terms rather than a particular file
      */
@@ -60,6 +66,9 @@ export interface MagnetData {
      * Combined as= and ws= parameters if they exist
      */
     urlList?: string[];
+    peerAddresses?: string[];
+    publicKey?: string;
+    publicKeyBuffer?: Buffer;
 }
 export declare function magnetDecode(uri: string): MagnetData;
 export declare function magnetEncode(data: MagnetData): string;

package/dist/src/index.js

@@ -1,4 +1,5 @@
 import { base32Decode } from '@ctrl/ts-base32';
+import * as bep53Range from './bep53.js';
 const start = 'magnet:?';
 export function magnetDecode(uri) {
     // Support 'stream-magnet:' as well
@@ -41,8 +42,30 @@ export function magnetDecode(uri) {
                 const decodedStr = base32Decode(m[1]);
                 result.infoHash = Buffer.from(decodedStr).toString('hex');
             }
+            else if ((m = xt.match(/^urn:btmh:1220(.{64})/))) {
+                result.infoHashV2 = m[1].toLowerCase();
+            }
         });
     }
+    if (result.xs) {
+        let m;
+        const xss = Array.isArray(result.xs) ? result.xs : [result.xs];
+        xss.forEach(xs => {
+            var _a;
+            if ((m = /^urn:btpk:(.{64})/.exec(xs))) {
+                result.publicKey = (_a = m[1]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            }
+        });
+    }
+    if (result.infoHash) {
+        result.infoHashBuffer = Buffer.from(result.infoHash, 'hex');
+    }
+    if (result.infoHashV2) {
+        result.infoHashV2Buffer = Buffer.from(result.infoHashV2, 'hex');
+    }
+    if (result.publicKey) {
+        result.publicKeyBuffer = Buffer.from(result.publicKey, 'hex');
+    }
     if (result.dn) {
         result.name = result.dn;
     }
@@ -65,8 +88,13 @@ export function magnetDecode(uri) {
     if (typeof result.ws === 'string' || Array.isArray(result.ws)) {
         result.urlList = result.urlList.concat(result.ws);
     }
+    result.peerAddresses = [];
+    if (typeof result['x.pe'] === 'string' || Array.isArray(result['x.pe'])) {
+        result.peerAddresses = result.peerAddresses.concat(result['x.pe']);
+    }
     result.announce = [...new Set(result.announce)].sort((a, b) => a.localeCompare(b));
     result.urlList = [...new Set(result.urlList)].sort((a, b) => a.localeCompare(b));
+    result.peerAddresses = [...new Set(result.peerAddresses)];
     return result;
 }
 /**
@@ -86,6 +114,10 @@ function parseQueryParamValue(key, val) {
     if (key === 'kt') {
         return decodeURIComponent(val).split('+');
     }
+    // bep53
+    if (key === 'so') {
+        return bep53Range.parseRange(decodeURIComponent(val).split(','));
+    }
     // Cast file index (ix) to a number
     if (key === 'ix') {
         return Number(val);
@@ -94,11 +126,44 @@ function parseQueryParamValue(key, val) {
 }
 export function magnetEncode(data) {
     const obj = { ...data }; // Shallow clone object
+    // Deduplicate xt by using a set
+    let xts = new Set();
+    if (obj.xt && typeof obj.xt === 'string') {
+        xts.add(obj.xt);
+    }
+    if (obj.xt && Array.isArray(obj.xt)) {
+        xts = new Set(obj.xt);
+    }
+    if (obj.infoHashBuffer) {
+        xts.add(`urn:btih:${obj.infoHashBuffer.toString('hex')}`);
+    }
+    if (obj.infoHash) {
+        xts.add(`urn:btih:${obj.infoHash}`);
+    }
+    if (obj.infoHashV2Buffer) {
+        xts.add((obj.xt = `urn:btmh:1220${obj.infoHashV2Buffer.toString('hex')}`));
+    }
+    if (obj.infoHashV2) {
+        xts.add(`urn:btmh:1220${obj.infoHashV2}`);
+    }
+    const xtsDeduped = Array.from(xts);
+    if (xtsDeduped.length === 1) {
+        obj.xt = xtsDeduped[0];
+    }
+    if (xtsDeduped.length > 1) {
+        obj.xt = xtsDeduped;
+    }
     // Support using convenience names, in addition to spec names
     // (example: `infoHash` for `xt`, `name` for `dn`)
     if (obj.infoHash) {
         obj.xt = `urn:btih:${obj.infoHash}`;
     }
+    if (obj.publicKeyBuffer) {
+        obj.xs = `urn:btpk:${obj.publicKeyBuffer.toString('hex')}`;
+    }
+    if (obj.publicKey) {
+        obj.xs = `urn:btpk:${obj.publicKey}`;
+    }
     if (obj.name) {
         obj.dn = obj.name;
     }
@@ -112,32 +177,44 @@ export function magnetEncode(data) {
         obj.ws = obj.urlList;
         delete obj.as;
     }
+    if (obj.peerAddresses) {
+        obj['x.pe'] = obj.peerAddresses;
+    }
     return Object.keys(obj)
-        .filter(key => key.length === 2)
+        .filter(key => key.length === 2 || key === 'x.pe')
         .reduce((prev, key, i) => {
         let acc = prev;
         const values = Array.isArray(obj[key]) ? obj[key] : [obj[key]];
         values.forEach((val, j) => {
-            if ((i > 0 || j > 0) && (key !== 'kt' || j === 0)) {
-                acc = `${acc}&`;
+            if ((i > 0 || j > 0) && ((key !== 'kt' && key !== 'so') || j === 0)) {
+                acc += '&';
             }
-            let res = val;
             if (key === 'dn') {
-                res = encodeURIComponent(val).replace(/%20/g, '+');
+                val = encodeURIComponent(val).replace(/%20/g, '+');
             }
-            if (key === 'tr' || key === 'xs' || key === 'as' || key === 'ws') {
-                res = encodeURIComponent(val);
+            if (key === 'tr' || key === 'as' || key === 'ws') {
+                val = encodeURIComponent(val);
+            }
+            // Don't URI encode BEP46 keys
+            if (key === 'xs' && !val.startsWith('urn:btpk:')) {
+                val = encodeURIComponent(val);
             }
             if (key === 'kt') {
-                res = encodeURIComponent(val);
+                val = encodeURIComponent(val);
+            }
+            if (key === 'so') {
+                return;
             }
             if (key === 'kt' && j > 0) {
-                acc = `${acc}+${res}`;
+                acc += `+${val}`;
             }
             else {
-                acc = `${acc}${key}=${res}`;
+                acc += `${key}=${val}`;
             }
         });
+        if (key === 'so') {
+            acc += `${key}=${bep53Range.composeRange(values)}`;
+        }
         return acc;
     }, `${start}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl/magnet-link",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Parse a magnet URI into an object",
   "author": "Scott Cooper <scttcper@gmail.com>",
   "homepage": "https://magnet-link.vercel.app",
@@ -34,13 +34,13 @@
     "@ctrl/ts-base32": "^2.1.1"
   },
   "devDependencies": {
-    "@ctrl/eslint-config": "3.2.0",
+    "@ctrl/eslint-config": "3.3.1",
     "@sindresorhus/tsconfig": "2.0.0",
-    "@types/node": "17.0.1",
-    "ava": "4.0.0-rc.1",
+    "@types/node": "17.0.9",
+    "ava": "4.0.1",
     "buffer": "6.0.3",
-    "c8": "7.10.0",
-    "tsm": "2.2.1",
+    "c8": "7.11.0",
+    "ts-node": "10.4.0",
     "typescript": "4.5.4"
   },
   "ava": {
@@ -51,7 +51,7 @@
       "ts": "module"
     },
     "nodeArguments": [
-      "--loader=tsm"
+      "--loader=ts-node/esm"
     ]
   },
   "workspaces": [