@tf2-automatic/tf2-format 8.0.0

package/src/lib/parsing/econ/parser.js

@@ -0,0 +1,747 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EconParser = void 0;
+const tslib_1 = require("tslib");
+const parser_1 = require("../parser");
+const TAGS_OF_INTEREST = new Set([
+    'Quality',
+    'Exterior',
+    'Rarity',
+    'Type',
+]);
+const NON_CRAFTABLE_DESCRIPTIONS = {
+    '( Not Usable in Crafting )': true,
+    '( Not Tradable, Marketable, or Usable in Crafting )': true,
+    '( Not Tradable, Marketable, Usable in Crafting, or Gift Wrappable )': true,
+};
+const WEAR = {
+    'Factory New': 1,
+    'Minimal Wear': 2,
+    'Field-Tested': 3,
+    'Well-Worn': 4,
+    'Battle Scarred': 5,
+};
+const KILLSTREAK_FABRICATORS = {
+    1: 6527,
+    2: 6523,
+    3: 6526,
+};
+const KILLSTREAK_TIERS = {
+    Killstreak: 1,
+    'Specialized Killstreak': 2,
+    'Professional Killstreak': 3,
+};
+/* eslint-disable @typescript-eslint/no-duplicate-enum-values */
+var IdentifiableDescription;
+(function (IdentifiableDescription) {
+    IdentifiableDescription[IdentifiableDescription["Skip"] = 0] = "Skip";
+    IdentifiableDescription[IdentifiableDescription["All"] = 1] = "All";
+    // Paints, spells and parts have the same precedence because it has been shown
+    // that they may appear in any order.
+    IdentifiableDescription[IdentifiableDescription["Paint"] = 1] = "Paint";
+    IdentifiableDescription[IdentifiableDescription["Spells"] = 1] = "Spells";
+    IdentifiableDescription[IdentifiableDescription["Parts"] = 1] = "Parts";
+    IdentifiableDescription[IdentifiableDescription["Effect"] = 2] = "Effect";
+    IdentifiableDescription[IdentifiableDescription["Festivized"] = 3] = "Festivized";
+    IdentifiableDescription[IdentifiableDescription["Killstreaker"] = 4] = "Killstreaker";
+    IdentifiableDescription[IdentifiableDescription["Sheen"] = 5] = "Sheen";
+    IdentifiableDescription[IdentifiableDescription["Killstreak"] = 6] = "Killstreak";
+    IdentifiableDescription[IdentifiableDescription["Texture"] = 7] = "Texture";
+    IdentifiableDescription[IdentifiableDescription["Input"] = 8] = "Input";
+    IdentifiableDescription[IdentifiableDescription["Output"] = 9] = "Output";
+    IdentifiableDescription[IdentifiableDescription["Target"] = 10] = "Target";
+    IdentifiableDescription[IdentifiableDescription["Uses"] = 11] = "Uses";
+    IdentifiableDescription[IdentifiableDescription["Craftable"] = 12] = "Craftable";
+})(IdentifiableDescription || (IdentifiableDescription = {}));
+/* eslint-enable @typescript-eslint/no-duplicate-enum-values */
+/**
+ * This is a mapping from the item type to the description that we want to
+ * start the description parsing from
+ */
+var TypeToIdentifiableDescription;
+(function (TypeToIdentifiableDescription) {
+    // Cosmetics can have many different descriptions so we will check for all
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Cosmetic"] = 1] = "Cosmetic";
+    // Taunts may have effects, so we will check for that
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Taunt 1"] = 2] = "Taunt 1";
+    // Nothing interesting in these items
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Party Favor"] = 0] = "Party Favor";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Action"] = 0] = "Action";
+    // Most craft items do not have descriptions but we will check for craftable
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Craft Item"] = 12] = "Craft Item";
+    // Check for uses on limited use items
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Festivizer"] = 11] = "Festivizer";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Tool"] = 11] = "Tool";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Gift"] = 11] = "Gift";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Strange Part"] = 11] = "Strange Part";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Usable Item"] = 11] = "Usable Item";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Crate"] = 11] = "Crate";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Unusualifier"] = 9] = "Unusualifier";
+    // Start checking for the target
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Strangifier"] = 10] = "Strangifier";
+    // War paints may have effects
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["War Paint"] = 2] = "War Paint";
+    // Start checking for inputs
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Recipe"] = 8] = "Recipe";
+    // We know what we should look for in Killstreak Kits
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Professional Killstreak Kit"] = 4] = "Professional Killstreak Kit";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Specialized Killstreak Kit"] = 5] = "Specialized Killstreak Kit";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Killstreak Kit"] = 6] = "Killstreak Kit";
+    // Start by checking for parts on any weapons
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Primary weapon"] = 1] = "Primary weapon";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Secondary weapon"] = 1] = "Secondary weapon";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Melee weapon"] = 1] = "Melee weapon";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Building"] = 1] = "Building";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Primary PDA"] = 1] = "Primary PDA";
+    TypeToIdentifiableDescription[TypeToIdentifiableDescription["Secondary PDA"] = 1] = "Secondary PDA";
+})(TypeToIdentifiableDescription || (TypeToIdentifiableDescription = {}));
+const WEAPON_TYPES = new Set([
+    'Primary weapon',
+    'Secondary weapon',
+    'Melee weapon',
+    'Building',
+    'Primary PDA',
+    'Secondary PDA',
+]);
+class EconParser extends parser_1.Parser {
+    extract(item) {
+        var _a, _b, _c;
+        const tags = EconParser.getTagAttributes(item);
+        let start;
+        if (tags.Type !== undefined) {
+            start = TypeToIdentifiableDescription[tags.Type];
+        }
+        else if (item.type !== '') {
+            // If we are missing the type from the tags we can in some cases get it
+            // from the type attribute of the item.
+            const match = item.type.match(/Level\s\d+\s(.+)/);
+            if (match !== null) {
+                start = TypeToIdentifiableDescription[match[1]];
+            }
+        }
+        const descriptions = EconParser.getDescriptionAttributes(item, tags, start);
+        const raw = {
+            type: (_a = tags.Type) !== null && _a !== void 0 ? _a : null,
+            assetid: item.assetid,
+            defindex: EconParser.getDefindex(item),
+            quality: (_b = tags.Quality) !== null && _b !== void 0 ? _b : null,
+            elevated: false,
+            craftable: descriptions.craftable,
+            tradable: item.tradable,
+            australium: EconParser.isAustralium(item, tags),
+            festivized: descriptions.festivized,
+            effect: descriptions.effect,
+            wear: (_c = tags.Exterior) !== null && _c !== void 0 ? _c : null,
+            paint: descriptions.paint,
+            killstreak: EconParser.getKillstreak(descriptions),
+            sheen: descriptions.sheen,
+            killstreaker: descriptions.killstreaker,
+            spells: descriptions.spells,
+            parts: descriptions.parts,
+            paintkit: descriptions.paintkit,
+            uses: descriptions.uses,
+            inputs: descriptions.inputs,
+            output: descriptions.output,
+            outputQuality: null,
+            target: descriptions.target,
+            crateSeries: EconParser.getCrateSeries(tags, item),
+        };
+        // Clean up the painkit name and overwrite the quality in certain cases
+        if (raw.paintkit !== null) {
+            if (tags.Rarity !== undefined && tags.Exterior !== undefined) {
+                // The length is the length of the description minus the length of the
+                // grade and wear
+                const length = item.descriptions[0].value.length -
+                    (tags.Exterior.length + 3 + tags.Rarity.length + 7);
+                // The new paintkit is the old paintkit without the name of the item
+                raw.paintkit = raw.paintkit.slice(0, raw.paintkit.length - length - 1);
+            }
+            else {
+                // Some items with a paintkit does not have a rarity, so we remove
+                // the " War Paint" from the paintkit name manually
+                const index = raw.paintkit.indexOf(' War Paint');
+                if (index !== -1) {
+                    raw.paintkit = raw.paintkit.slice(0, index);
+                }
+            }
+            const isWarPaint = tags.Type === 'War Paint';
+            // Set the quality of the item based on certain conditions to better match
+            // how the TF2 GC stores the quality of items with a paint kit.
+            if (raw.effect !== null && !isWarPaint) {
+                // The quality of unusual war paints is still "Unusual", hence the check
+                // for the type.
+                raw.quality = 'Decorated Weapon';
+            }
+            else if (isWarPaint && descriptions.statclock) {
+                // If the item is a war paint and it has a statclock attatched then we
+                // know that the quality is strange.
+                raw.quality = 'Strange';
+            }
+        }
+        // Handle elevated qualities
+        if (raw.quality !== 'Strange') {
+            const lastChar = item.type.charCodeAt(item.type.length - 1);
+            // Check if last char is a number
+            if (lastChar >= 48 && lastChar <= 57) {
+                let dashIndex = -1;
+                let colonIndex = -1;
+                // We can skip 2 chars, this is because we know that there is atleast a
+                // space before the number
+                for (let i = item.type.length - 3; i >= 0; i--) {
+                    if (item.type.charAt(i) === '-') {
+                        dashIndex = i;
+                        break;
+                    }
+                    if (item.type.charAt(i) === ':') {
+                        colonIndex = i;
+                    }
+                }
+                if (colonIndex > dashIndex) {
+                    raw.elevated = true;
+                }
+            }
+        }
+        if (raw.output !== null) {
+            // This is a little dumb but it is for consistency with the TF2 API
+            raw.outputQuality = 'Unique';
+            if (raw.killstreak !== 0) {
+                // Handle Killstreak Kit Fabricators
+                raw.target = raw.output.slice(raw.output.indexOf('Killstreak ') + 11, raw.output.lastIndexOf(' Kit'));
+                raw.output = 'Kit';
+            }
+            else if (raw.output.endsWith('Strangifier')) {
+                // Handle Strangifier Chemistry Sets
+                raw.target = raw.output.slice(0, raw.output.length - 12);
+                raw.output = 'Strangifier';
+            }
+            else if (raw.output.startsWith("Collector's ")) {
+                // Handle Collector's Chemistry Sets
+                raw.output = raw.output.slice(12);
+                raw.outputQuality = "Collector's";
+            }
+        }
+        return raw;
+    }
+    parse(raw) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (raw.defindex === null) {
+                throw new Error('Defindex is null');
+            }
+            // TODO: Can probably optimize the fetching of values
+            // Maybe start fetching and then await the promises at the end?
+            // Get quality from some cache
+            let quality = raw.quality !== null ? this.schema.getQualityByName(raw.quality) : null;
+            if (quality === undefined) {
+                // Quality is not in cache, fetch it from the schema
+                quality = yield this.schema.fetchQualityByName(raw.quality);
+            }
+            else if (quality instanceof Error) {
+                throw quality;
+            }
+            if (!quality) {
+                throw new Error('Quality is undefined');
+            }
+            let effect = raw.effect !== null ? this.schema.getEffectByName(raw.effect) : null;
+            if (effect === undefined) {
+                effect = yield this.schema.fetchEffectByName(raw.effect);
+            }
+            else if (effect instanceof Error) {
+                throw effect;
+            }
+            let paintkit = raw.paintkit !== null ? this.schema.getTextureByName(raw.paintkit) : null;
+            if (paintkit === undefined) {
+                paintkit = yield this.schema.fetchTextureByName(raw.paintkit);
+            }
+            else if (paintkit instanceof Error) {
+                throw paintkit;
+            }
+            let wear = null;
+            if (raw.wear !== null) {
+                wear = WEAR[raw.wear];
+            }
+            let target = raw.target !== null ? this.schema.getDefindexByName(raw.target) : null;
+            if (target === undefined) {
+                target = yield this.schema.fetchDefindexByName(raw.target);
+            }
+            let outputQuality = raw.outputQuality !== null
+                ? this.schema.getQualityByName(raw.outputQuality)
+                : null;
+            if (outputQuality === undefined) {
+                outputQuality = yield this.schema.fetchQualityByName(raw.outputQuality);
+            }
+            else if (outputQuality instanceof Error) {
+                throw outputQuality;
+            }
+            let output = null;
+            if (raw.output !== null) {
+                if (raw.output === 'Kit') {
+                    output = KILLSTREAK_FABRICATORS[raw.killstreak];
+                }
+                else if (raw.output === 'Strangifier') {
+                    output = 6522;
+                }
+                else if (raw.defindex === 20006) {
+                    output = yield this.schema.fetchDefindexByName(raw.output);
+                }
+                else {
+                    const intermediate = this.schema.getDefindexByName(raw.output);
+                    if (intermediate === undefined) {
+                        output = yield this.schema.fetchDefindexByName(raw.output);
+                    }
+                    else {
+                        output = intermediate;
+                    }
+                }
+            }
+            const parts = [];
+            for (const scoreType of raw.parts) {
+                const part = yield this.getPartByScoreType(scoreType, raw.type);
+                if (part !== null) {
+                    parts.push(part);
+                }
+            }
+            const spells = [];
+            for (const spell of raw.spells) {
+                const cached = this.schema.getSpellByName(spell);
+                if (cached instanceof Error) {
+                    throw cached;
+                }
+                else if (cached !== undefined) {
+                    spells.push(cached);
+                    continue;
+                }
+                const fetched = yield this.schema.fetchSpellByName(spell);
+                if (fetched) {
+                    spells.push(fetched);
+                }
+            }
+            let paint = raw.paint !== null ? this.schema.getDefindexByName(raw.paint) : null;
+            if (paint === undefined) {
+                paint = yield this.schema.fetchDefindexByName(raw.paint);
+            }
+            let inputs = null;
+            if (raw.inputs !== null) {
+                inputs = [];
+                for (const rawInput of raw.inputs) {
+                    let name = rawInput.name;
+                    let rawQuality = 'Unique';
+                    // Handle strange items for strangifier chemistry sets
+                    if (name.startsWith('Strange ') && raw.output === 'Strangifier') {
+                        name = name.slice(8);
+                        rawQuality = 'Strange';
+                    }
+                    // Get the quality
+                    let quality = this.schema.getQualityByName(rawQuality);
+                    if (quality === undefined) {
+                        quality = yield this.schema.fetchQualityByName(rawQuality);
+                    }
+                    else if (quality instanceof Error) {
+                        throw quality;
+                    }
+                    const input = {
+                        quality,
+                        amount: rawInput.amount,
+                    };
+                    // Handle killstreak items for killstreak kit fabricators
+                    if (name.startsWith('Unique') && name.endsWith(' Killstreak Item')) {
+                        const killstreak = name.slice(7, name.length - 5);
+                        name = null;
+                        input.killstreak = KILLSTREAK_TIERS[killstreak];
+                    }
+                    if (name !== null) {
+                        // Get the defindex of the input item
+                        let defindex = this.getInputByName(name);
+                        if (defindex === undefined) {
+                            defindex = yield this.fetchInputByName(name);
+                        }
+                        if (!defindex) {
+                            throw new Error(`Could not find the defindex of the input item "${name}"`);
+                        }
+                        input.defindex = defindex;
+                    }
+                    inputs.push(input);
+                }
+            }
+            const parsed = {
+                assetid: raw.assetid,
+                defindex: raw.defindex,
+                quality,
+                craftable: raw.craftable,
+                tradable: raw.tradable,
+                australium: raw.australium,
+                festivized: raw.festivized,
+                effect,
+                wear,
+                paintkit,
+                killstreak: raw.killstreak,
+                target,
+                output,
+                outputQuality,
+                elevated: raw.elevated,
+                crateSeries: raw.crateSeries,
+                paint,
+                parts,
+                spells,
+                sheen: raw.sheen,
+                killstreaker: raw.killstreaker,
+                inputs,
+            };
+            return parsed;
+        });
+    }
+    getPartByScoreType(scoreType, itemType) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let part = this.schema.getStrangePartByScoreType(scoreType);
+            if (part === undefined) {
+                part = yield this.schema.fetchStrangePartByScoreType(scoreType);
+            }
+            if (!part) {
+                return part;
+            }
+            let item = this.schema.getItemByDefindex(part);
+            if (item === undefined) {
+                item = yield this.schema.fetchItemByDefindex(part);
+            }
+            else if (item instanceof Error) {
+                throw item;
+            }
+            if (!item) {
+                return null;
+            }
+            if (item.name.startsWith('Strange Cosmetic Part: ') &&
+                itemType !== 'Cosmetic') {
+                return null;
+            }
+            return part;
+        });
+    }
+    getInputByName(name) {
+        if (name.startsWith('The ')) {
+            const input = this.schema.getDefindexByName(name.slice(4));
+            if (input) {
+                return input;
+            }
+        }
+        return this.schema.getDefindexByName(name);
+    }
+    fetchInputByName(name) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (name.startsWith('The ')) {
+                const input = yield this.schema.fetchDefindexByName(name.slice(4));
+                if (input) {
+                    return input;
+                }
+            }
+            return this.schema.fetchDefindexByName(name);
+        });
+    }
+    static getDefindex(item) {
+        for (const action of item.actions) {
+            if (action.name !== 'Item Wiki Page...') {
+                continue;
+            }
+            const defindex = new URL(action.link).searchParams.get('id');
+            if (defindex === null) {
+                return null;
+            }
+            return parseInt(defindex, 10);
+        }
+        return null;
+    }
+    static getKillstreak(descriptions) {
+        if (descriptions.killstreaker !== null) {
+            return 3;
+        }
+        else if (descriptions.sheen !== null) {
+            return 2;
+        }
+        else if (descriptions.killstreak) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    static getCrateSeries(tags, item) {
+        if (tags.Type !== 'Crate') {
+            return null;
+        }
+        // We can get the crate series from the description of the item, but that
+        // would add more description checks.
+        const lastChar = item.market_hash_name.charCodeAt(item.market_hash_name.length - 1);
+        if (!(lastChar >= 48 && lastChar <= 57)) {
+            return null;
+        }
+        // We know there is atleast one number in the name
+        let series = lastChar - 48;
+        const length = item.market_hash_name.length;
+        // We start from the end of the string and go backwards towards a number sign
+        for (let i = length - 2; i >= length - 4; i--) {
+            // Get the char code of the current character
+            const charCode = item.market_hash_name.charCodeAt(i);
+            if (charCode >= 48 && charCode <= 57) {
+                // The character is a number
+                series = series + (charCode - 48) * Math.pow(10, length - i - 1);
+            }
+            else if (charCode === 35) {
+                // The character is a number sign
+                return series;
+            }
+            else {
+                // The character is not a number or a number sign
+                break;
+            }
+        }
+        return null;
+    }
+    static getTagAttributes(item) {
+        const tags = {};
+        let tagCount = 0;
+        for (const tag of item.tags) {
+            if (TAGS_OF_INTEREST.has(tag.category)) {
+                tagCount++;
+                tags[tag.category] = tag.name;
+                if (tagCount === TAGS_OF_INTEREST.size) {
+                    break;
+                }
+            }
+        }
+        return tags;
+    }
+    static isAustralium(item, tags) {
+        var _a;
+        // It might be possible for australiums to be qualities other than Strange.
+        // But I think all australium items are a weapon of some sort.
+        if (!WEAPON_TYPES.has((_a = tags.Type) !== null && _a !== void 0 ? _a : '')) {
+            return false;
+        }
+        // All australium items have Australium in their name. Except for "Saxxy",
+        // but that item is always australium.
+        return item.market_hash_name.includes('Australium ');
+    }
+    /**
+     * This function tries to extract as much useful information as possible from
+     * the descriptions of an item.
+     * @param item The item to extract the information from
+     * @param tags The tags of the item
+     * @param start The description to start from
+     * @returns An object with the extracted information
+     */
+    static getDescriptionAttributes(item, tags, start = IdentifiableDescription.Paint) {
+        const attributes = {
+            craftable: true,
+            effect: null,
+            killstreak: false,
+            sheen: null,
+            killstreaker: null,
+            spells: [],
+            parts: [],
+            paint: null,
+            festivized: false,
+            paintkit: null,
+            uses: null,
+            inputs: null,
+            output: null,
+            target: null,
+            grade: null,
+            statclock: false,
+        };
+        if (start === IdentifiableDescription.Skip) {
+            return attributes;
+        }
+        let next = start;
+        const descriptions = item.descriptions;
+        // Add empty description to make sure we do not get out of bounds errors
+        descriptions.push({ value: '' });
+        let i = 0;
+        // I don't like that this is outside the switch statement but it is the most
+        // efficient way to do it.
+        if (tags.Rarity !== undefined) {
+            if (tags.Exterior !== undefined &&
+                descriptions[i].value.startsWith(tags.Rarity + ' Grade ') &&
+                descriptions[i].value.endsWith(' (' + tags.Exterior + ')')) {
+                attributes.grade = descriptions[i].value;
+                i++;
+            }
+            if (descriptions[i].value === 'Strange Stat Clock Attached') {
+                attributes.statclock = true;
+                i++;
+            }
+        }
+        loop: while (i < descriptions.length - 1) {
+            // Skip descriptions that are too short/long to contain any useful information
+            // TODO: Fix "magic numbers"
+            if (descriptions[i].value.length < 10) {
+                i++;
+                continue;
+            }
+            /* eslint-disable no-fallthrough */
+            switch (next) {
+                case IdentifiableDescription.All:
+                case IdentifiableDescription.Paint:
+                    if (descriptions[i].value.startsWith('Paint Color: ')) {
+                        attributes.paint = descriptions[i].value.slice(13);
+                        next = IdentifiableDescription.Spells;
+                        i++;
+                    }
+                case IdentifiableDescription.Spells:
+                    if (descriptions[i].value.startsWith('Halloween: ')) {
+                        attributes.spells.push(descriptions[i].value.slice(11, descriptions[i].value.lastIndexOf(' (spell only active during event)')));
+                        // This is redundant
+                        next = IdentifiableDescription.Spells;
+                        i++;
+                        // We break because that might be the best to do if there are more spells
+                        continue loop;
+                    }
+                case IdentifiableDescription.Parts:
+                    if (descriptions[i].value.startsWith('(') &&
+                        // Make sure it does not match Craftable/Tradable/Marketable descriptions
+                        descriptions[i].value.charAt(1) !== ' ') {
+                        attributes.parts.push(descriptions[i].value.slice(1, descriptions[i].value.lastIndexOf(': ')));
+                        next = IdentifiableDescription.Parts;
+                        i++;
+                        // Break again so we can check for more parts
+                        continue loop;
+                    }
+                    else if (descriptions[i].value.startsWith('     ')) {
+                        attributes.parts.push(descriptions[i].value.slice(5, descriptions[i].value.lastIndexOf(': ')));
+                        next = IdentifiableDescription.Parts;
+                        i++;
+                        // Break again so we can check for more parts
+                        continue loop;
+                    }
+                case IdentifiableDescription.Effect:
+                    if (descriptions[i].value.startsWith('\u2605 Unusual Effect: ')) {
+                        attributes.effect = descriptions[i].value.slice(18);
+                        next = IdentifiableDescription.Festivized;
+                        i++;
+                    }
+                case IdentifiableDescription.Festivized:
+                    if (descriptions[i].value === 'Festivized') {
+                        attributes.festivized = true;
+                        next = IdentifiableDescription.Killstreaker;
+                        i++;
+                    }
+                case IdentifiableDescription.Killstreaker:
+                    if (descriptions[i].value.startsWith('Killstreaker: ')) {
+                        attributes.killstreaker = descriptions[i].value.slice(14);
+                        next = IdentifiableDescription.Sheen;
+                        i++;
+                    }
+                case IdentifiableDescription.Sheen:
+                    if (descriptions[i].value.startsWith('Sheen: ')) {
+                        attributes.sheen = descriptions[i].value.slice(7);
+                        next = IdentifiableDescription.Killstreak;
+                        i++;
+                    }
+                case IdentifiableDescription.Killstreak:
+                    if (descriptions[i].value === 'Killstreaks Active') {
+                        attributes.killstreak = true;
+                        next = IdentifiableDescription.Texture;
+                        i++;
+                    }
+                case IdentifiableDescription.Texture: {
+                    let extract = false;
+                    if (descriptions[i].value.endsWith('Collection')) {
+                        if (tags.Exterior !== undefined) {
+                            next = IdentifiableDescription.Texture;
+                            extract = true;
+                        }
+                        i++;
+                        // Might be a little "dangerous" to use these while loops
+                        while (descriptions[i].value.charAt(0) === ' ') {
+                            i++;
+                        }
+                    }
+                    let paintkit = null;
+                    let found = false;
+                    if (descriptions[i].value.startsWith('\u2714 ')) {
+                        paintkit = descriptions[i].value.slice(2);
+                        found = true;
+                    }
+                    else if (descriptions[i].value.startsWith('\u2605 ')) {
+                        found = true;
+                        paintkit = descriptions[i].value.slice(2);
+                    }
+                    if (found) {
+                        i++;
+                        // Skip all the other stuff if any
+                        while (descriptions[i].value.charAt(0) === ' ') {
+                            i++;
+                        }
+                        if (extract) {
+                            attributes.paintkit = paintkit;
+                            next = IdentifiableDescription.Uses;
+                        }
+                        // We continue the loop so that we skip to the next checks
+                        continue loop;
+                    }
+                }
+                case IdentifiableDescription.Input:
+                    if (descriptions[i].value ===
+                        'The following are the inputs that must be fulfilled.') {
+                        i++;
+                        const inputs = [];
+                        attributes.inputs = inputs;
+                        while (descriptions[i].value !== ' ') {
+                            const split = descriptions[i].value.lastIndexOf(' x ');
+                            const name = descriptions[i].value.slice(0, split);
+                            const amount = parseInt(descriptions[i].value.slice(split + 3), 10);
+                            inputs.push({ name, amount });
+                            i++;
+                        }
+                        next = IdentifiableDescription.Output;
+                    }
+                case IdentifiableDescription.Output:
+                    if (descriptions[i].value ===
+                        'You will receive all of the following outputs once all of the inputs are fulfilled.') {
+                        i++;
+                        attributes.output = descriptions[i].value;
+                        i++;
+                        if (descriptions[i].value !== ' ') {
+                            let start = 1;
+                            if (descriptions[i].value.startsWith('(Killstreaker: ')) {
+                                start = descriptions[i].value.indexOf(', ');
+                                attributes.killstreaker = descriptions[i].value.slice(15, start);
+                                start += 2;
+                            }
+                            attributes.sheen = descriptions[i].value.slice(start + 7, descriptions[i].value.length - 1);
+                            i++;
+                        }
+                        next = IdentifiableDescription.Uses;
+                    }
+                case IdentifiableDescription.Target:
+                    if (descriptions[i].value.startsWith('This ')) {
+                        // Can probably speed this up by just slicing strings instead of
+                        // using regex
+                        const match = descriptions[i].value.match(/^This .*? can be applied to a (.*?)(?=\.)/);
+                        if (match !== null) {
+                            attributes.target = match[1];
+                            next = IdentifiableDescription.Uses;
+                            i++;
+                        }
+                    }
+                case IdentifiableDescription.Uses:
+                    if (descriptions[i].value.startsWith('This is a limited use item. Uses: ')) {
+                        attributes.uses = parseInt(descriptions[i].value.slice(34), 10);
+                        next = IdentifiableDescription.Craftable;
+                        i++;
+                    }
+                case IdentifiableDescription.Craftable:
+                    if (NON_CRAFTABLE_DESCRIPTIONS[descriptions[i].value]) {
+                        attributes.craftable = false;
+                        // We found everything we could possibly look for.
+                        break loop;
+                    }
+                default:
+                    i++;
+                    continue loop;
+            }
+            /* eslint-enable no-fallthrough */
+        }
+        return attributes;
+    }
+}
+exports.EconParser = EconParser;
+tslib_1.__exportStar(require("./types"), exports);
+//# sourceMappingURL=parser.js.map