@vlydev/cs2-masked-inspect-ts 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VlyDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,221 @@
+# @vlydev/cs2-masked-inspect-ts
+
+TypeScript library for encoding and decoding CS2 masked inspect links — fully typed, no runtime dependencies.
+
+## Installation
+
+```bash
+npm install @vlydev/cs2-masked-inspect-ts
+```
+
+## Usage
+
+```typescript
+import { InspectLink, ItemPreviewData, Sticker } from '@vlydev/cs2-masked-inspect-ts';
+
+// Decode a masked inspect link payload or full URL
+const item = InspectLink.deserialize('00183C20B803280538E9A3C5DD0340E102C246A0D1');
+console.log(item.defIndex);   // 60
+console.log(item.paintIndex); // 440
+console.log(item.paintWear);  // 0.005411375779658556
+
+// Also accepts full steam:// URLs
+const item2 = InspectLink.deserialize(
+  'steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20A00183C20B803280538...'
+);
+
+// Encode an item back to a hex payload
+const data = new ItemPreviewData({
+  defIndex:   7,
+  paintIndex: 422,
+  paintSeed:  922,
+  paintWear:  0.04121,
+  rarity:     3,
+  quality:    4,
+  stickers: [
+    new Sticker({ slot: 0, stickerId: 7436 }),
+    new Sticker({ slot: 1, stickerId: 5144 }),
+  ],
+});
+const hex = InspectLink.serialize(data);
+console.log(hex); // uppercase hex string starting with '00'
+
+// Check link type
+InspectLink.isMasked('steam://...csgo_econ_action_preview%20A0011...');  // true — decodable offline
+InspectLink.isClassic('steam://...csgo_econ_action_preview%20S123A456D789'); // true — classic S/A/D format
+```
+
+## API
+
+### `InspectLink`
+
+#### `InspectLink.serialize(data: ItemPreviewData): string`
+
+Encodes an `ItemPreviewData` to an uppercase hex payload (key_byte = 0x00, no XOR).
+
+Throws:
+- `RangeError` if `paintWear` is outside `[0.0, 1.0]`
+- `RangeError` if `customName` exceeds 100 characters
+
+#### `InspectLink.deserialize(input: string): ItemPreviewData`
+
+Decodes a hex payload or full inspect URL into an `ItemPreviewData`.
+
+Accepts:
+- Raw hex strings (uppercase or lowercase)
+- `steam://rungame/...` URLs
+- `csgo://rungame/...` URLs
+- Hybrid format: `S\d+A\d+D<hexproto>`
+
+Handles the XOR obfuscation used in native CS2 links (key_byte != 0x00).
+
+Throws:
+- `RangeError` if payload exceeds 4096 hex chars
+- `TypeError` if payload is too short (< 6 bytes) or invalid hex
+
+#### `InspectLink.isMasked(link: string): boolean`
+
+Returns `true` if the link contains a decodable protobuf payload (can be decoded offline without Steam API).
+
+#### `InspectLink.isClassic(link: string): boolean`
+
+Returns `true` if the link is a classic `S/A/D` inspect URL with decimal D value (requires Steam API to decode).
+
+### `ItemPreviewData`
+
+```typescript
+new ItemPreviewData({
+  accountId?: number | bigint;   // Steam account ID
+  itemId?: number | bigint;      // Item asset ID (may exceed 2^32)
+  defIndex?: number;             // Weapon/item definition index
+  paintIndex?: number;           // Skin paint index
+  rarity?: number;               // Item rarity
+  quality?: number;              // Item quality
+  paintWear?: number | null;     // Float value [0.0, 1.0], null if not applicable
+  paintSeed?: number;            // Pattern seed [0, 1000]
+  killEaterScoreType?: number;   // StatTrak type
+  killEaterValue?: number;       // StatTrak value
+  customName?: string;           // Custom name tag (max 100 chars)
+  stickers?: Sticker[];          // Applied stickers (fields 1-4)
+  inventory?: number;
+  origin?: number;
+  questId?: number;
+  dropReason?: number;
+  musicIndex?: number;
+  entIndex?: number;
+  petIndex?: number;
+  keychains?: Sticker[];         // Applied keychains (field 5 slot)
+})
+```
+
+### `Sticker`
+
+Used for both stickers and keychains.
+
+```typescript
+new Sticker({
+  slot?: number;               // Slot position on the item
+  stickerId?: number;          // Sticker/keychain definition ID
+  wear?: number | null;        // Sticker wear (float32, wire type 5)
+  scale?: number | null;       // Sticker scale (float32, wire type 5)
+  rotation?: number | null;    // Sticker rotation (float32, wire type 5)
+  tintId?: number;             // Tint/color ID
+  offsetX?: number | null;     // X offset (float32, wire type 5)
+  offsetY?: number | null;     // Y offset (float32, wire type 5)
+  offsetZ?: number | null;     // Z offset (float32, wire type 5)
+  pattern?: number;            // Pattern index
+  highlightReel?: number | null; // Highlight reel frame (keychains)
+})
+```
+
+## Binary Format
+
+```
+[key_byte] [proto_bytes XOR'd with key] [4-byte checksum XOR'd with key]
+```
+
+- `key_byte = 0x00` — tool-generated links (no XOR)
+- `key_byte != 0x00` — native CS2 links (every byte XOR'd with key_byte)
+
+### Checksum Algorithm
+
+```
+buffer   = [0x00] + proto_bytes
+crc      = crc32(buffer)           // polynomial 0xEDB88320
+xored    = (crc & 0xffff) ^ (len(proto_bytes) * crc)  [unsigned 32-bit]
+checksum = big-endian uint32
+```
+
+### PaintWear Encoding
+
+`paintWear` is stored on the wire as a `uint32` varint whose bit pattern is the IEEE 754 float32 representation of the float value. This library handles the conversion transparently using `DataView`.
+
+## Protobuf Schema Reference
+
+`CEconItemPreviewDataBlock` fields:
+
+| Field | Name | Type |
+|-------|------|------|
+| 1 | accountId | varint |
+| 2 | itemId | varint (uint64) |
+| 3 | defIndex | varint |
+| 4 | paintIndex | varint |
+| 5 | rarity | varint |
+| 6 | quality | varint |
+| 7 | paintWear | varint (float32 bits) |
+| 8 | paintSeed | varint |
+| 9 | killEaterScoreType | varint |
+| 10 | killEaterValue | varint |
+| 11 | customName | length-delimited (string) |
+| 12 | stickers | length-delimited (repeated) |
+| 13 | inventory | varint |
+| 14 | origin | varint |
+| 15 | questId | varint |
+| 16 | dropReason | varint |
+| 17 | musicIndex | varint |
+| 18 | entIndex | varint |
+| 19 | petIndex | varint |
+| 20 | keychains | length-delimited (repeated) |
+
+`Sticker` fields:
+
+| Field | Name | Type |
+|-------|------|------|
+| 1 | slot | varint |
+| 2 | stickerId | varint |
+| 3 | wear | fixed32 LE (float32) |
+| 4 | scale | fixed32 LE (float32) |
+| 5 | rotation | fixed32 LE (float32) |
+| 6 | tintId | varint |
+| 7 | offsetX | fixed32 LE (float32) |
+| 8 | offsetY | fixed32 LE (float32) |
+| 9 | offsetZ | fixed32 LE (float32) |
+| 10 | pattern | varint |
+| 11 | highlightReel | varint (omit if null) |
+
+## Test Vectors
+
+```typescript
+// Tool-generated (key 0x00): DefIndex=60, PaintIndex=440, PaintSeed=353, PaintWear≈0.00541, Rarity=5
+'00183C20B803280538E9A3C5DD0340E102C246A0D1'
+
+// Native CS2 (key 0xE3): ItemId=46876117973, DefIndex=7, PaintIndex=422, PaintSeed=922, PaintWear≈0.04121
+// Stickers: [7436, 5144, 6970, 8069, 5592]
+'E3F3367440334DE2FBE4C345E0CBE0D3...'
+```
+
+## Running Tests
+
+```bash
+npm test
+```
+
+Tests use Node.js built-in test runner (`node:test`) with `--experimental-strip-types` (Node 22+) to run TypeScript directly without compilation.
+
+## Contributing
+
+Pull requests welcome. Please ensure `npm test` passes before submitting.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

package/dist/cjs/InspectLink.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Encodes and decodes CS2 masked inspect links.
+ *
+ * Binary format:
+ *   [key_byte] [proto_bytes XOR'd with key] [4-byte checksum XOR'd with key]
+ *
+ * For tool-generated links key_byte = 0x00 (no XOR needed).
+ * For native CS2 links key_byte != 0x00 — every byte must be XOR'd before parsing.
+ *
+ * Checksum:
+ *   buffer   = [0x00] + proto_bytes
+ *   crc      = crc32(buffer)
+ *   xored    = (crc & 0xffff) ^ (len(proto_bytes) * crc)  [unsigned 32-bit]
+ *   checksum = big-endian uint32 of (xored & 0xFFFFFFFF)
+ */
+import { ItemPreviewData } from './ItemPreviewData.ts';
+export declare class InspectLink {
+    /**
+     * Encode an ItemPreviewData to an uppercase hex inspect-link payload.
+     *
+     * The returned string can be appended to a steam:// inspect URL or used
+     * standalone. The key_byte is always 0x00 (no XOR applied).
+     */
+    static serialize(data: ItemPreviewData): string;
+    /**
+     * Returns true if the link contains a decodable protobuf payload (can be decoded offline).
+     */
+    static isMasked(link: string): boolean;
+    /**
+     * Returns true if the link is a classic S/A/D inspect URL with decimal did.
+     */
+    static isClassic(link: string): boolean;
+    /**
+     * Decode an inspect-link hex payload (or full URL) into an ItemPreviewData.
+     *
+     * Accepts:
+     *   - A raw uppercase or lowercase hex string
+     *   - A full steam://rungame/... inspect URL
+     *   - A CS2-style csgo://rungame/... URL
+     *
+     * Handles the XOR obfuscation used in native CS2 links.
+     */
+    static deserialize(input: string): ItemPreviewData;
+}
+//# sourceMappingURL=InspectLink.d.ts.map

package/dist/cjs/InspectLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InspectLink.d.ts","sourceRoot":"","sources":["../../src/InspectLink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AA6PvD,qBAAa,WAAW;IACtB;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM;IAiB/C;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOtC;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIvC;;;;;;;;;OASG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe;CA+BnD"}

package/dist/cjs/InspectLink.js

@@ -0,0 +1,368 @@
+"use strict";
+/**
+ * Encodes and decodes CS2 masked inspect links.
+ *
+ * Binary format:
+ *   [key_byte] [proto_bytes XOR'd with key] [4-byte checksum XOR'd with key]
+ *
+ * For tool-generated links key_byte = 0x00 (no XOR needed).
+ * For native CS2 links key_byte != 0x00 — every byte must be XOR'd before parsing.
+ *
+ * Checksum:
+ *   buffer   = [0x00] + proto_bytes
+ *   crc      = crc32(buffer)
+ *   xored    = (crc & 0xffff) ^ (len(proto_bytes) * crc)  [unsigned 32-bit]
+ *   checksum = big-endian uint32 of (xored & 0xFFFFFFFF)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectLink = void 0;
+const ItemPreviewData_ts_1 = require("./ItemPreviewData.js");
+const Sticker_ts_1 = require("./Sticker.js");
+const reader_ts_1 = require("./proto/reader.js");
+const writer_ts_1 = require("./proto/writer.js");
+const crc32_ts_1 = require("./crc32.js");
+// ------------------------------------------------------------------
+// Checksum helpers
+// ------------------------------------------------------------------
+/**
+ * Compute checksum over [0x00] + proto_bytes.
+ * Returns a 4-byte big-endian Uint8Array.
+ */
+function computeChecksum(buffer, protoLen) {
+    const crcVal = (0, crc32_ts_1.crc32)(buffer);
+    const val = BigInt(((crcVal & 0xFFFF) ^ (protoLen * crcVal)) >>> 0) & 0xffffffffn;
+    const result = new Uint8Array(4);
+    const dv = new DataView(result.buffer);
+    dv.setUint32(0, Number(val), false); // big-endian
+    return result;
+}
+// ------------------------------------------------------------------
+// float32 <-> uint32 reinterpretation
+// ------------------------------------------------------------------
+function float32ToUint32(f) {
+    const dv = new DataView(new ArrayBuffer(4));
+    dv.setFloat32(0, f, true); // little-endian
+    return dv.getUint32(0, true);
+}
+function uint32ToFloat32(u) {
+    const dv = new DataView(new ArrayBuffer(4));
+    dv.setUint32(0, u >>> 0, true);
+    return dv.getFloat32(0, true);
+}
+// ------------------------------------------------------------------
+// Hex encoding / decoding helpers
+// ------------------------------------------------------------------
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('')
+        .toUpperCase();
+}
+function concatBytes(...arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// URL extraction
+// ------------------------------------------------------------------
+const INSPECT_URL_RE = /(?:%20|\s|\+)A([0-9A-Fa-f]+)/i;
+const HYBRID_URL_RE = /S\d+A\d+D([0-9A-Fa-f]+)$/i;
+const CLASSIC_URL_RE = /csgo_econ_action_preview(?:%20|\s)[SM]\d+A\d+D\d+$/i;
+const MASKED_URL_RE = /csgo_econ_action_preview(?:%20|\s)[0-9A-Fa-f]{10,}$/i;
+function extractHex(input) {
+    const stripped = input.trim();
+    // Hybrid format: S\d+A\d+D<hexproto>
+    const mh = stripped.match(HYBRID_URL_RE);
+    if (mh && /[A-Fa-f]/.test(mh[1]))
+        return mh[1];
+    // Classic/market URL: A<hex> preceded by %20, space, or + (A is a prefix marker, not hex).
+    // If stripping A yields odd-length hex, A is actually the first byte of the payload —
+    // fall through to the pure-masked check below which captures it with A included.
+    const m = stripped.match(INSPECT_URL_RE);
+    if (m && m[1].length % 2 === 0)
+        return m[1];
+    // Pure masked format: csgo_econ_action_preview%20<hexblob> (no S/A/M prefix).
+    // Also handles payloads whose first hex character happens to be A.
+    const mm = stripped.match(/csgo_econ_action_preview(?:%20|\s|\+)([0-9A-Fa-f]{10,})$/i);
+    if (mm)
+        return mm[1];
+    // Bare hex — strip whitespace
+    return stripped.replace(/\s+/g, '');
+}
+// ------------------------------------------------------------------
+// Sticker encode / decode
+// ------------------------------------------------------------------
+function encodeSticker(s) {
+    const w = new writer_ts_1.ProtoWriter();
+    w.writeUint32(1, s.slot);
+    w.writeUint32(2, s.stickerId);
+    if (s.wear !== null)
+        w.writeFloat32Fixed(3, s.wear);
+    if (s.scale !== null)
+        w.writeFloat32Fixed(4, s.scale);
+    if (s.rotation !== null)
+        w.writeFloat32Fixed(5, s.rotation);
+    w.writeUint32(6, s.tintId);
+    if (s.offsetX !== null)
+        w.writeFloat32Fixed(7, s.offsetX);
+    if (s.offsetY !== null)
+        w.writeFloat32Fixed(8, s.offsetY);
+    if (s.offsetZ !== null)
+        w.writeFloat32Fixed(9, s.offsetZ);
+    w.writeUint32(10, s.pattern);
+    if (s.highlightReel != null)
+        w.writeUint32(11, s.highlightReel);
+    return w.toBytes();
+}
+function decodeSticker(data) {
+    const reader = new reader_ts_1.ProtoReader(data);
+    const s = new Sticker_ts_1.Sticker();
+    for (const f of reader.readAllFields()) {
+        switch (f.field) {
+            case 1:
+                s.slot = Number(f.value);
+                break;
+            case 2:
+                s.stickerId = Number(f.value);
+                break;
+            case 3: {
+                const bytes = f.value;
+                const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+                s.wear = dv.getFloat32(0, true);
+                break;
+            }
+            case 4: {
+                const bytes = f.value;
+                const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+                s.scale = dv.getFloat32(0, true);
+                break;
+            }
+            case 5: {
+                const bytes = f.value;
+                const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+                s.rotation = dv.getFloat32(0, true);
+                break;
+            }
+            case 6:
+                s.tintId = Number(f.value);
+                break;
+            case 7: {
+                const bytes = f.value;
+                const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+                s.offsetX = dv.getFloat32(0, true);
+                break;
+            }
+            case 8: {
+                const bytes = f.value;
+                const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+                s.offsetY = dv.getFloat32(0, true);
+                break;
+            }
+            case 9: {
+                const bytes = f.value;
+                const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+                s.offsetZ = dv.getFloat32(0, true);
+                break;
+            }
+            case 10:
+                s.pattern = Number(f.value);
+                break;
+            case 11:
+                s.highlightReel = Number(f.value);
+                break;
+            default: break;
+        }
+    }
+    return s;
+}
+// ------------------------------------------------------------------
+// ItemPreviewData encode / decode
+// ------------------------------------------------------------------
+function encodeItem(item) {
+    const w = new writer_ts_1.ProtoWriter();
+    w.writeUint32(1, item.accountId);
+    w.writeUint64(2, item.itemId);
+    w.writeUint32(3, item.defIndex);
+    w.writeUint32(4, item.paintIndex);
+    w.writeUint32(5, item.rarity);
+    w.writeUint32(6, item.quality);
+    // paintWear: float32 reinterpreted as uint32 varint
+    if (item.paintWear != null) {
+        w.writeUint32(7, float32ToUint32(item.paintWear));
+    }
+    w.writeUint32(8, item.paintSeed);
+    w.writeUint32(9, item.killEaterScoreType);
+    w.writeUint32(10, item.killEaterValue);
+    w.writeString(11, item.customName);
+    for (const sticker of item.stickers) {
+        w.writeRawBytes(12, encodeSticker(sticker));
+    }
+    w.writeUint32(13, item.inventory);
+    w.writeUint32(14, item.origin);
+    w.writeUint32(15, item.questId);
+    w.writeUint32(16, item.dropReason);
+    w.writeUint32(17, item.musicIndex);
+    w.writeInt32(18, item.entIndex);
+    w.writeUint32(19, item.petIndex);
+    for (const kc of item.keychains) {
+        w.writeRawBytes(20, encodeSticker(kc));
+    }
+    return w.toBytes();
+}
+function decodeItem(data) {
+    const reader = new reader_ts_1.ProtoReader(data);
+    const item = new ItemPreviewData_ts_1.ItemPreviewData();
+    for (const f of reader.readAllFields()) {
+        switch (f.field) {
+            case 1:
+                item.accountId = Number(f.value);
+                break;
+            case 2:
+                item.itemId = Number(f.value);
+                break;
+            case 3:
+                item.defIndex = Number(f.value);
+                break;
+            case 4:
+                item.paintIndex = Number(f.value);
+                break;
+            case 5:
+                item.rarity = Number(f.value);
+                break;
+            case 6:
+                item.quality = Number(f.value);
+                break;
+            case 7:
+                item.paintWear = uint32ToFloat32(Number(f.value));
+                break;
+            case 8:
+                item.paintSeed = Number(f.value);
+                break;
+            case 9:
+                item.killEaterScoreType = Number(f.value);
+                break;
+            case 10:
+                item.killEaterValue = Number(f.value);
+                break;
+            case 11:
+                item.customName = new TextDecoder().decode(f.value);
+                break;
+            case 12:
+                item.stickers.push(decodeSticker(f.value));
+                break;
+            case 13:
+                item.inventory = Number(f.value);
+                break;
+            case 14:
+                item.origin = Number(f.value);
+                break;
+            case 15:
+                item.questId = Number(f.value);
+                break;
+            case 16:
+                item.dropReason = Number(f.value);
+                break;
+            case 17:
+                item.musicIndex = Number(f.value);
+                break;
+            case 18:
+                item.entIndex = Number(f.value);
+                break;
+            case 19:
+                item.petIndex = Number(f.value);
+                break;
+            case 20:
+                item.keychains.push(decodeSticker(f.value));
+                break;
+            default: break;
+        }
+    }
+    return item;
+}
+// ------------------------------------------------------------------
+// Public API
+// ------------------------------------------------------------------
+class InspectLink {
+    /**
+     * Encode an ItemPreviewData to an uppercase hex inspect-link payload.
+     *
+     * The returned string can be appended to a steam:// inspect URL or used
+     * standalone. The key_byte is always 0x00 (no XOR applied).
+     */
+    static serialize(data) {
+        if (data.paintWear != null && (data.paintWear < 0.0 || data.paintWear > 1.0)) {
+            throw new RangeError(`paintwear must be in [0.0, 1.0], got ${data.paintWear}`);
+        }
+        if (data.customName != null && data.customName.length > 100) {
+            throw new RangeError(`customname must not exceed 100 characters, got ${data.customName.length}`);
+        }
+        const protoBytes = encodeItem(data);
+        const buffer = concatBytes(new Uint8Array([0x00]), protoBytes);
+        const checksum = computeChecksum(buffer, protoBytes.length);
+        return bytesToHex(concatBytes(buffer, checksum));
+    }
+    /**
+     * Returns true if the link contains a decodable protobuf payload (can be decoded offline).
+     */
+    static isMasked(link) {
+        const s = link.trim();
+        if (MASKED_URL_RE.test(s))
+            return true;
+        const m = s.match(HYBRID_URL_RE);
+        return !!(m && /[A-Fa-f]/.test(m[1]));
+    }
+    /**
+     * Returns true if the link is a classic S/A/D inspect URL with decimal did.
+     */
+    static isClassic(link) {
+        return CLASSIC_URL_RE.test(link.trim());
+    }
+    /**
+     * Decode an inspect-link hex payload (or full URL) into an ItemPreviewData.
+     *
+     * Accepts:
+     *   - A raw uppercase or lowercase hex string
+     *   - A full steam://rungame/... inspect URL
+     *   - A CS2-style csgo://rungame/... URL
+     *
+     * Handles the XOR obfuscation used in native CS2 links.
+     */
+    static deserialize(input) {
+        const hex = extractHex(input);
+        if (hex.length > 4096) {
+            throw new RangeError(`Payload too long (max 4096 hex chars): "${input.slice(0, 64)}..."`);
+        }
+        const raw = hexToBytes(hex);
+        if (raw.length < 6) {
+            throw new TypeError(`Payload too short or invalid hex: "${input}"`);
+        }
+        const key = raw[0];
+        let decrypted;
+        if (key === 0) {
+            decrypted = raw;
+        }
+        else {
+            decrypted = new Uint8Array(raw.length);
+            for (let i = 0; i < raw.length; i++) {
+                decrypted[i] = raw[i] ^ key;
+            }
+        }
+        // Layout: [key_byte] [proto_bytes] [4-byte checksum]
+        const protoBytes = decrypted.slice(1, decrypted.length - 4);
+        return decodeItem(protoBytes);
+    }
+}
+exports.InspectLink = InspectLink;