@funpixel/tools 0.0.0-stage → 0.1.0

package/dist/doctor/unity-import-rules.js

@@ -0,0 +1,874 @@
+import { methodsOf } from "./unity-project.js";
+import { platformName } from "./unity-meta.js";
+const E = (o) => o;
+export const ENUMS = {
+    TextureImporterType: E({ Default: 0, Image: 0, NormalMap: 1, Bump: 1, GUI: 2, Cookie: 4, Lightmap: 6, Cursor: 7, Sprite: 8, SingleChannel: 10, DirectionalLightmap: 11, Shadowmask: 12 }),
+    TextureImporterNPOTScale: E({ None: 0, ToNearest: 1, ToLarger: 2, ToSmaller: 3 }),
+    TextureImporterCompression: E({ Uncompressed: 0, Compressed: 1, CompressedHQ: 2, CompressedLQ: 3 }),
+    FilterMode: E({ Point: 0, Bilinear: 1, Trilinear: 2 }),
+    TextureWrapMode: E({ Repeat: 0, Clamp: 1, Mirror: 2, MirrorOnce: 3 }),
+    SpriteImportMode: E({ None: 0, Single: 1, Multiple: 2, Polygon: 3 }),
+    TextureImporterAlphaSource: E({ None: 0, FromInput: 1, FromGrayScale: 2 }),
+    TextureImporterFormat: E({
+        Automatic: -1, Alpha8: 1, ARGB16: 2, RGB24: 3, RGBA32: 4, ARGB32: 5, RGB16: 7, R16: 9, DXT1: 10, DXT5: 12, RGBA16: 13, RHalf: 15, RGHalf: 16, RGBAHalf: 17,
+        RFloat: 18, RGFloat: 19, RGBAFloat: 20, RGB9E5: 22, BC6H: 24, BC7: 25, BC4: 26, BC5: 27, DXT1Crunched: 28, DXT5Crunched: 29, PVRTC_RGB2: 30, PVRTC_RGBA2: 31,
+        PVRTC_RGB4: 32, PVRTC_RGBA4: 33, ETC_RGB4: 34, EAC_R: 41, EAC_R_SIGNED: 42, EAC_RG: 43, EAC_RG_SIGNED: 44, ETC2_RGB4: 45, ETC2_RGB4_PUNCHTHROUGH_ALPHA: 46,
+        ETC2_RGBA8: 47, ASTC_4x4: 48, ASTC_5x5: 49, ASTC_6x6: 50, ASTC_8x8: 51, ASTC_10x10: 52, ASTC_12x12: 53, ASTC_RGB_4x4: 48, ASTC_RGB_5x5: 49, ASTC_RGB_6x6: 50,
+        ASTC_RGB_8x8: 51, ASTC_RGB_10x10: 52, ASTC_RGB_12x12: 53, RG16: 62, R8: 63, ETC_RGB4Crunched: 64, ETC2_RGBA8Crunched: 65, ASTC_HDR_4x4: 66, ASTC_HDR_5x5: 67,
+        ASTC_HDR_6x6: 68, ASTC_HDR_8x8: 69, ASTC_HDR_10x10: 70, ASTC_HDR_12x12: 71, RG32: 72, RGB48: 73, RGBA64: 74,
+    }),
+    AudioCompressionFormat: E({ PCM: 0, Vorbis: 1, ADPCM: 2, MP3: 3, VAG: 4, HEVAG: 5, XMA: 6, AAC: 7, GCADPCM: 8, ATRAC9: 9 }),
+    AudioClipLoadType: E({ DecompressOnLoad: 0, CompressedInMemory: 1, Streaming: 2 }),
+    AudioSampleRateSetting: E({ PreserveSampleRate: 0, OptimizeSampleRate: 1, OverrideSampleRate: 2 }),
+};
+export function enumName(type, value) {
+    if (!type)
+        return value;
+    const hit = Object.entries(ENUMS[type] ?? {}).find(([, v]) => String(v) === value);
+    return hit ? hit[0] : value;
+}
+const TEXTURE_FIELDS = {
+    textureType: { where: 'top', key: 'textureType', conv: 'TextureImporterType' },
+    mipmapEnabled: { where: 'top', key: 'enableMipMap', conv: 'bool' },
+    npotScale: { where: 'top', key: 'nPOTScale', conv: 'TextureImporterNPOTScale' },
+    textureCompression: { where: 'DefaultTexturePlatform', key: 'textureCompression', conv: 'TextureImporterCompression' },
+    maxTextureSize: { where: 'DefaultTexturePlatform', key: 'maxTextureSize', conv: 'num' },
+    alphaIsTransparency: { where: 'top', key: 'alphaIsTransparency', conv: 'bool' },
+    sRGBTexture: { where: 'top', key: 'sRGBTexture', conv: 'bool' },
+    isReadable: { where: 'top', key: 'isReadable', conv: 'bool' },
+    spritePixelsPerUnit: { where: 'top', key: 'spritePixelsToUnits', conv: 'num' },
+    filterMode: { where: 'top', key: 'filterMode', conv: 'FilterMode' },
+    wrapMode: { where: 'top', key: 'wrapU', conv: 'TextureWrapMode' },
+    spriteImportMode: { where: 'top', key: 'spriteMode', conv: 'SpriteImportMode' },
+    anisoLevel: { where: 'top', key: 'aniso', conv: 'num' },
+    alphaSource: { where: 'top', key: 'alphaUsage', conv: 'TextureImporterAlphaSource' },
+};
+const TEXTURE_SETTINGS_FIELDS = { ...TEXTURE_FIELDS, readable: TEXTURE_FIELDS.isReadable, spriteMode: { where: 'top', key: 'spriteMode', conv: 'num' }, aniso: TEXTURE_FIELDS.anisoLevel, spritePixelsPerUnit: TEXTURE_FIELDS.spritePixelsPerUnit };
+const PLATFORM_FIELDS = {
+    overridden: { where: 'platform', key: 'overridden', conv: 'bool' },
+    format: { where: 'platform', key: 'textureFormat', conv: 'TextureImporterFormat' },
+    maxTextureSize: { where: 'platform', key: 'maxTextureSize', conv: 'num' },
+    textureCompression: { where: 'platform', key: 'textureCompression', conv: 'TextureImporterCompression' },
+    compressionQuality: { where: 'platform', key: 'compressionQuality', conv: 'num' },
+};
+const AUDIO_FIELDS = {
+    forceToMono: { where: 'top', key: 'forceToMono', conv: 'bool' },
+    loadInBackground: { where: 'top', key: 'loadInBackground', conv: 'bool' },
+    ambisonic: { where: 'top', key: 'ambisonic', conv: 'bool' },
+    preloadAudioData: { where: 'defaults', key: 'preloadAudioData', conv: 'bool' },
+};
+const AUDIO_DEFAULT_FIELDS = {
+    loadType: { where: 'defaults', key: 'loadType', conv: 'AudioClipLoadType' },
+    compressionFormat: { where: 'defaults', key: 'compressionFormat', conv: 'AudioCompressionFormat' },
+    quality: { where: 'defaults', key: 'quality', conv: 'num' },
+    sampleRateSetting: { where: 'defaults', key: 'sampleRateSetting', conv: 'AudioSampleRateSetting' },
+    sampleRateOverride: { where: 'defaults', key: 'sampleRateOverride', conv: 'num' },
+    preloadAudioData: { where: 'defaults', key: 'preloadAudioData', conv: 'bool' },
+};
+export const KEY_ENUM = Object.fromEntries([...Object.values(TEXTURE_FIELDS), ...Object.values(PLATFORM_FIELDS), ...Object.values(AUDIO_DEFAULT_FIELDS)].filter((f) => ENUMS[f.conv]).map((f) => [f.key, f.conv]));
+const UNKNOWN = { t: 'unknown' };
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function skipLiteral(s, i) {
+    let j = i;
+    let verbatim = false;
+    while (s[j] === '@' || s[j] === '$') {
+        if (s[j] === '@')
+            verbatim = true;
+        j++;
+    }
+    const q = s[j];
+    j++;
+    for (; j < s.length; j++) {
+        if (verbatim) {
+            if (s[j] === '"' && s[j + 1] === '"') {
+                j++;
+                continue;
+            }
+            if (s[j] === '"')
+                return j + 1;
+        }
+        else {
+            if (s[j] === '\\') {
+                j++;
+                continue;
+            }
+            if (s[j] === q)
+                return j + 1;
+            if (s[j] === '\n')
+                return j;
+        }
+    }
+    return j;
+}
+const startsLiteral = (s, i) => s[i] === '"' || s[i] === "'" || ((s[i] === '@' || s[i] === '$') && (s[i + 1] === '"' || ((s[i + 1] === '@' || s[i + 1] === '$') && s[i + 2] === '"')));
+function skipGroup(s, i) {
+    let depth = 0;
+    for (let j = i; j < s.length; j++) {
+        if (startsLiteral(s, j)) {
+            j = skipLiteral(s, j) - 1;
+            continue;
+        }
+        if (s[j] === '(' || s[j] === '[' || s[j] === '{')
+            depth++;
+        else if (s[j] === ')' || s[j] === ']' || s[j] === '}') {
+            if (--depth === 0)
+                return j + 1;
+        }
+    }
+    return s.length;
+}
+function splitTop(s, ops) {
+    const parts = [];
+    const found = [];
+    let last = 0;
+    for (let j = 0; j < s.length; j++) {
+        if (startsLiteral(s, j)) {
+            j = skipLiteral(s, j) - 1;
+            continue;
+        }
+        if (s[j] === '(' || s[j] === '[' || s[j] === '{') {
+            j = skipGroup(s, j) - 1;
+            continue;
+        }
+        const op = ops.find((o) => s.startsWith(o, j));
+        if (!op)
+            continue;
+        if ((op === '<' || op === '>') && (s[j + 1] === '=' || s[j - 1] === '='))
+            continue;
+        parts.push(s.slice(last, j));
+        found.push(op);
+        last = j + op.length;
+        j += op.length - 1;
+    }
+    parts.push(s.slice(last));
+    return { parts, ops: found };
+}
+const unwrap = (s) => {
+    let t = s.trim();
+    while (t.startsWith('(') && skipGroup(t, 0) === t.length)
+        t = t.slice(1, -1).trim();
+    return t;
+};
+function strLiteral(s) {
+    const t = s.trim();
+    const m = /^(@?)"((?:[^"\\]|\\.|"")*)"$/.exec(t) ?? /^\$"([^"{}]*)"$/.exec(t);
+    if (m) {
+        if (m.length === 2)
+            return m[1];
+        return m[1] ? m[2].replace(/""/g, '"') : m[2].replace(/\\(.)/g, (_, c) => (c === 'n' ? '\n' : c === 't' ? '\t' : c));
+    }
+    const c = /^'(\\?.)'$/.exec(t);
+    return c ? (c[1].length === 2 ? c[1][1] : c[1]) : null;
+}
+const KEYWORD = /^(if|else|foreach|for|while|do|switch|try|catch|finally|using|lock|return|unchecked|checked)\b/;
+function parseStmts(s) {
+    const out = [];
+    let i = 0;
+    while (i < s.length) {
+        const [stmts, next] = parseOne(s, i);
+        out.push(...stmts);
+        if (next <= i)
+            break;
+        i = next;
+    }
+    return out;
+}
+const ws = (s, i) => { while (i < s.length && /\s/.test(s[i]))
+    i++; return i; };
+function parseOne(s, i) {
+    i = ws(s, i);
+    if (i >= s.length)
+        return [[], s.length];
+    if (s[i] === ';')
+        return [[], i + 1];
+    if (s[i] === '{') {
+        const end = skipGroup(s, i);
+        return [parseStmts(s.slice(i + 1, end - 1)), end];
+    }
+    const kw = KEYWORD.exec(s.slice(i, i + 12))?.[1];
+    if (kw === 'if') {
+        const open = s.indexOf('(', i);
+        const close = skipGroup(s, open);
+        const cond = s.slice(open + 1, close - 1);
+        const [then, after] = parseOne(s, close);
+        const e = ws(s, after);
+        if (/^else\b/.test(s.slice(e, e + 5))) {
+            const [els, end] = parseOne(s, e + 4);
+            return [[{ k: 'if', cond, then, else: els }], end];
+        }
+        return [[{ k: 'if', cond, then, else: [] }], after];
+    }
+    if (kw === 'foreach') {
+        const open = s.indexOf('(', i);
+        const close = skipGroup(s, open);
+        const head = s.slice(open + 1, close - 1);
+        const [body, end] = parseOne(s, close);
+        const m = /^\s*(?:var|string)\s+(\w+)\s+in\s+([\s\S]+)$/.exec(head);
+        if (m)
+            return [[{ k: 'foreach', v: m[1], items: m[2].trim(), body }], end];
+        return [[{ k: 'opaque', text: s.slice(i, end) }], end];
+    }
+    if (kw === 'return') {
+        const end = statementEnd(s, i);
+        return [[{ k: 'return', text: s.slice(i + 6, end - 1).trim() }], end];
+    }
+    if (kw && kw !== 'else') {
+        let j = ws(s, i + kw.length);
+        if (s[j] === '(')
+            j = skipGroup(s, j);
+        const [, end] = parseOne(s, j);
+        return [[{ k: 'opaque', text: s.slice(i, end) }], end];
+    }
+    if (kw === 'else')
+        return [[], i + 4];
+    const end = statementEnd(s, i);
+    return [[{ k: 'expr', text: s.slice(i, end).replace(/;\s*$/, '').trim() }], end];
+}
+function statementEnd(s, i) {
+    for (let j = i; j < s.length; j++) {
+        if (startsLiteral(s, j)) {
+            j = skipLiteral(s, j) - 1;
+            continue;
+        }
+        if (s[j] === '(' || s[j] === '[' || s[j] === '{') {
+            j = skipGroup(s, j) - 1;
+            continue;
+        }
+        if (s[j] === ';')
+            return j + 1;
+    }
+    return s.length;
+}
+const NOT_A_METHOD = new Set(['if', 'for', 'foreach', 'while', 'switch', 'catch', 'using', 'lock', 'return', 'new', 'nameof', 'typeof', 'sizeof', 'default']);
+function paramsOf(list) {
+    if (!list.trim())
+        return [];
+    return splitTop(list, [',']).parts.map((p) => /(\w+)\s*(?:=[^=][\s\S]*)?$/.exec(p.trim())?.[1] ?? '');
+}
+function methodsIn(code, blank) {
+    const out = new Map();
+    const add = (m) => out.set(m.name, [...(out.get(m.name) ?? []), m]);
+    for (const m of methodsOf(blank)) {
+        const before = code.slice(Math.max(0, m.start - 600), m.start);
+        const head = /(\w+)\s*(?:<[^<>()]*>)?\s*\(((?:[^()]|\([^()]*\))*)\)\s*(?:where\s[^{;]+)?\s*$/.exec(before);
+        if (!head || NOT_A_METHOD.has(head[1]))
+            continue;
+        add({ name: head[1], params: paramsOf(head[2]), body: parseStmts(code.slice(m.start + 1, m.end)), expr: null });
+    }
+    for (const m of code.matchAll(/\b[\w<>[\].]+\s+(\w+)\s*\(([^()]*)\)\s*=>\s*/g)) {
+        if (NOT_A_METHOD.has(m[1]))
+            continue;
+        const from = m.index + m[0].length;
+        const end = statementEnd(code, from);
+        add({ name: m[1], params: paramsOf(m[2]), body: [], expr: code.slice(from, end - 1).trim() });
+    }
+    return out;
+}
+export function ruleScope(files) {
+    const consts = new Map();
+    const falseStatics = new Set();
+    for (const f of files) {
+        const classes = [...f.withStrings.matchAll(/\b(?:class|struct)\s+(\w+)/g)].map((m) => ({ at: m.index, name: m[1] }));
+        for (const m of f.withStrings.matchAll(/\b(?:const|static\s+readonly)\s+(?:string|int|float)\s+(\w+)\s*=\s*([^;]+);/g)) {
+            const cls = classes.filter((c) => c.at < m.index).pop()?.name;
+            consts.set(m[1], [...(consts.get(m[1]) ?? []), { file: f.rel, cls, text: m[2].trim() }]);
+        }
+        for (const m of f.code.matchAll(/\bstatic\s+(?:volatile\s+)?bool\s+(\w+)\s*(?:=\s*false\s*)?;/g))
+            falseStatics.add(m[1]);
+    }
+    return { methods: new Map(), consts, falseStatics };
+}
+const fieldId = (where, key) => `${where}\u0000${key}`;
+class Run {
+    vars = new Map();
+    fields = new Map();
+    dead = false;
+    murky = false;
+    ret = null;
+    depth = 0;
+    maybe = new Set();
+    any = false;
+    scope;
+    methods;
+    kind;
+    file;
+    cls;
+    constructor(scope, methods, kind, file, cls) {
+        this.scope = scope;
+        this.methods = methods;
+        this.kind = kind;
+        this.file = file;
+        this.cls = cls;
+    }
+    str(e) {
+        const v = this.value(e);
+        return v.t === 'str' ? v.v : null;
+    }
+    num(e) {
+        const v = this.value(e);
+        return v.t === 'num' ? v.v : null;
+    }
+    constant(name) {
+        const parts = name.split('.');
+        const all = this.scope.consts.get(parts[parts.length - 1]) ?? [];
+        const one = (xs) => (new Set(xs.map((x) => x.text)).size === 1 ? xs[0].text : null);
+        const text = parts.length > 1
+            ? one(all.filter((x) => x.cls === parts[parts.length - 2]))
+            : one(all.filter((x) => x.file === this.file && x.cls === this.cls)) ?? one(all.filter((x) => x.file === this.file)) ?? one(all);
+        if (!text || this.depth > 12)
+            return UNKNOWN;
+        this.depth++;
+        try {
+            return this.value(text);
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    value(expr) {
+        const e = unwrap(expr);
+        if (!e)
+            return UNKNOWN;
+        const q = this.ternary(e);
+        if (q) {
+            const c = this.bool(q.cond);
+            if (c === true)
+                return this.value(q.a);
+            if (c === false)
+                return this.value(q.b);
+            const a = this.value(q.a);
+            const b = this.value(q.b);
+            return same(a, b) ? a : UNKNOWN;
+        }
+        if (/^\((?:int|float|double|long|string|bool)\)/.test(e))
+            return this.value(e.replace(/^\(\w+\)/, ''));
+        const lit = strLiteral(e);
+        if (lit !== null)
+            return { t: 'str', v: lit };
+        if (/^-?(?:\d+\.?\d*|\.\d+)[fFdDmM]?$/.test(e))
+            return { t: 'num', v: parseFloat(e) };
+        if (e === 'true' || e === 'false')
+            return { t: 'bool', v: e === 'true' };
+        if (splitTop(e, ['||', '&&', '==', '!=']).parts.length > 1 || /^!/.test(e) || / is /.test(e)) {
+            const b = this.bool(e);
+            return b === null ? UNKNOWN : { t: 'bool', v: b };
+        }
+        const rel = splitTop(e, ['<=', '>=', '<', '>']);
+        if (rel.parts.length === 2 && !/^new\b/.test(e) && !e.includes('=>')) {
+            const b = this.bool(e);
+            return b === null ? UNKNOWN : { t: 'bool', v: b };
+        }
+        const sum = splitTop(e, ['+', '-']);
+        if (sum.parts.length > 1 && sum.parts[0].trim()) {
+            const vals = sum.parts.map((p) => this.value(p));
+            if (vals.every((v) => v.t === 'num'))
+                return { t: 'num', v: vals.reduce((acc, v, i) => (i === 0 ? v.v : sum.ops[i - 1] === '+' ? acc + v.v : acc - v.v), 0) };
+            if (sum.ops.every((o) => o === '+') && vals.every((v) => v.t === 'str' || v.t === 'num'))
+                return { t: 'str', v: vals.map((v) => String(v.v)).join('') };
+            return UNKNOWN;
+        }
+        const arr = /^new\s*(?:string)?\s*\[\s*\]\s*\{([\s\S]*)\}$/.exec(e);
+        if (arr) {
+            const items = splitTop(arr[1], [',']).parts.filter((p) => p.trim()).map((p) => this.str(p));
+            return items.every((x) => x !== null) ? { t: 'strs', v: items } : UNKNOWN;
+        }
+        if (/^new\s+TextureImporterSettings\s*\(\s*\)$/.test(e))
+            return { t: 'tset' };
+        if (/^new\s+(?:UnityEditor\.)?TextureImporterPlatformSettings\b/.test(e))
+            return { t: 'plat', target: null };
+        if (/^\(\s*(?:UnityEditor\.)?(?:Texture|Audio)Importer\s*\)\s*assetImporter$|^assetImporter(?:\s+as\s+(?:UnityEditor\.)?(?:Texture|Audio)Importer)?$/.test(e))
+            return { t: 'imp' };
+        return this.chain(e);
+    }
+    ternary(e) {
+        let depthQ = 0;
+        let qAt = -1;
+        for (let j = 0; j < e.length; j++) {
+            if (startsLiteral(e, j)) {
+                j = skipLiteral(e, j) - 1;
+                continue;
+            }
+            if (e[j] === '(' || e[j] === '[' || e[j] === '{') {
+                j = skipGroup(e, j) - 1;
+                continue;
+            }
+            if (e[j] === '?' && e[j + 1] !== '?' && e[j + 1] !== '.' && e[j - 1] !== '?') {
+                if (qAt < 0)
+                    qAt = j;
+                depthQ++;
+            }
+            else if (e[j] === ':' && qAt >= 0 && e[j - 1] !== ':' && e[j + 1] !== ':') {
+                if (--depthQ === 0)
+                    return { cond: e.slice(0, qAt), a: e.slice(qAt + 1, j), b: e.slice(j + 1) };
+            }
+        }
+        return null;
+    }
+    chain(e) {
+        const segs = splitChain(e);
+        if (!segs)
+            return UNKNOWN;
+        const names = segs.map((s) => s.name);
+        if (segs.every((s) => s.args === null) && names.length >= 2) {
+            const type = names[names.length - 2];
+            if (ENUMS[type])
+                return { t: 'enum', type, member: names[names.length - 1] };
+        }
+        const callAt = segs.findIndex((s) => s.args !== null);
+        let cur;
+        let k;
+        const statics = callAt > 0 ? names.slice(0, callAt).join('.') : '';
+        if (callAt > 0 && /^(?:System\.IO\.)?Path$|^(?:System\.)?String$|^string$/.test(statics)) {
+            cur = this.staticCall(names[callAt], segs[callAt].args);
+            k = callAt + 1;
+        }
+        else if (callAt === 0) {
+            cur = this.call(names[0], segs[0].args);
+            k = 1;
+        }
+        else {
+            cur = UNKNOWN;
+            k = 0;
+            for (let n = callAt < 0 ? segs.length : callAt; n >= 1; n--) {
+                const name = names.slice(0, n).join('.');
+                const v = n === 1 && this.vars.has(name) ? this.vars.get(name) : n === 1 && name === 'assetPath' ? this.vars.get('assetPath') ?? UNKNOWN : this.constant(name);
+                if (v.t !== 'unknown') {
+                    cur = v;
+                    k = n;
+                    break;
+                }
+                if (n === 1 && this.scope.falseStatics.has(name)) {
+                    cur = { t: 'bool', v: false };
+                    k = 1;
+                    break;
+                }
+            }
+            if (k === 0)
+                return UNKNOWN;
+        }
+        for (; k < segs.length && cur.t !== 'unknown'; k++)
+            cur = this.member(cur, segs[k].name, segs[k].args);
+        return cur;
+    }
+    member(obj, name, args) {
+        if (obj.t === 'str') {
+            const s = obj.v;
+            if (args === null)
+                return name === 'Length' ? { t: 'num', v: s.length } : UNKNOWN;
+            const a = args.map((x) => this.value(x));
+            const sa = (i) => (a[i]?.t === 'str' ? a[i].v : null);
+            const na = (i) => (a[i]?.t === 'num' ? a[i].v : null);
+            const ci = args.some((x) => /IgnoreCase/.test(x));
+            const cmp = (x) => (ci ? x.toLowerCase() : x);
+            switch (name) {
+                case 'Replace': return sa(0) !== null && sa(1) !== null ? { t: 'str', v: s.split(sa(0)).join(sa(1)) } : UNKNOWN;
+                case 'ToLowerInvariant':
+                case 'ToLower': return { t: 'str', v: s.toLowerCase() };
+                case 'ToUpperInvariant':
+                case 'ToUpper': return { t: 'str', v: s.toUpperCase() };
+                case 'Trim': return args.length ? UNKNOWN : { t: 'str', v: s.trim() };
+                case 'TrimEnd': {
+                    const chars = a.map((x) => (x.t === 'str' ? x.v : null));
+                    if (chars.some((c) => c === null))
+                        return UNKNOWN;
+                    let t = s;
+                    while (t && chars.includes(t[t.length - 1]))
+                        t = t.slice(0, -1);
+                    return { t: 'str', v: t };
+                }
+                case 'Contains': return sa(0) !== null ? { t: 'bool', v: cmp(s).includes(cmp(sa(0))) } : UNKNOWN;
+                case 'StartsWith': return sa(0) !== null ? { t: 'bool', v: cmp(s).startsWith(cmp(sa(0))) } : UNKNOWN;
+                case 'EndsWith': return sa(0) !== null ? { t: 'bool', v: cmp(s).endsWith(cmp(sa(0))) } : UNKNOWN;
+                case 'IndexOf': return sa(0) !== null ? { t: 'num', v: s.indexOf(sa(0)) } : UNKNOWN;
+                case 'LastIndexOf': return sa(0) !== null ? { t: 'num', v: s.lastIndexOf(sa(0)) } : UNKNOWN;
+                case 'Substring': return na(0) !== null ? { t: 'str', v: na(1) !== null ? s.substr(na(0), na(1)) : s.slice(na(0)) } : UNKNOWN;
+                default: return UNKNOWN;
+            }
+        }
+        if (obj.t === 'imp' || obj.t === 'plat' || obj.t === 'adef' || obj.t === 'tset') {
+            if (args !== null) {
+                if (obj.t === 'imp' && name === 'GetPlatformTextureSettings') {
+                    const t = this.str(args[0] ?? '');
+                    return { t: 'plat', target: t === null ? null : platformName(t) };
+                }
+                return UNKNOWN;
+            }
+            if (obj.t === 'imp' && name === 'defaultSampleSettings')
+                return { t: 'adef' };
+            if (obj.t === 'imp' && name === 'assetPath')
+                return this.vars.get('assetPath') ?? UNKNOWN;
+            const f = this.fieldOf(obj, name);
+            return f ? this.fields.get(f) ?? UNKNOWN : UNKNOWN;
+        }
+        return UNKNOWN;
+    }
+    staticCall(name, args) {
+        const p = this.str(args[0] ?? '');
+        if (name === 'IsNullOrEmpty')
+            return p === null ? UNKNOWN : { t: 'bool', v: p === '' };
+        if (p === null)
+            return UNKNOWN;
+        const norm = p.replace(/\\/g, '/');
+        const base = norm.slice(norm.lastIndexOf('/') + 1);
+        const dot = base.lastIndexOf('.');
+        switch (name) {
+            case 'GetFileName': return { t: 'str', v: base };
+            case 'GetFileNameWithoutExtension': return { t: 'str', v: dot > 0 ? base.slice(0, dot) : base };
+            case 'GetExtension': return { t: 'str', v: dot >= 0 ? base.slice(dot) : '' };
+            case 'GetDirectoryName': return { t: 'str', v: norm.includes('/') ? norm.slice(0, norm.lastIndexOf('/')) : '' };
+            default: return UNKNOWN;
+        }
+    }
+    call(name, args) {
+        const m = this.methods.get(name)?.find((x) => x.params.length === args.length);
+        if (!m || this.depth > 6)
+            return UNKNOWN;
+        const bound = args.map((a) => this.value(a));
+        const saved = { vars: this.vars, ret: this.ret, dead: this.dead, murky: this.murky };
+        this.vars = new Map([...(this.vars.has('assetPath') ? [['assetPath', this.vars.get('assetPath')]] : [])]);
+        m.params.forEach((p, i) => this.vars.set(p, bound[i]));
+        this.depth++;
+        try {
+            if (m.expr !== null)
+                return this.value(m.expr);
+            this.ret = null;
+            this.dead = false;
+            this.exec(m.body);
+            return this.ret ?? UNKNOWN;
+        }
+        finally {
+            this.depth--;
+            this.vars = saved.vars;
+            this.ret = saved.ret;
+            this.dead = saved.dead;
+            this.murky = saved.murky;
+        }
+    }
+    bool(expr) {
+        const e = unwrap(expr);
+        const or = splitTop(e, ['||']);
+        if (or.parts.length > 1) {
+            const vs = or.parts.map((p) => this.bool(p));
+            return vs.includes(true) ? true : vs.every((v) => v === false) ? false : null;
+        }
+        const and = splitTop(e, ['&&']);
+        if (and.parts.length > 1) {
+            const vs = and.parts.map((p) => this.bool(p));
+            return vs.includes(false) ? false : vs.every((v) => v === true) ? true : null;
+        }
+        if (e.startsWith('!') && !e.startsWith('!=')) {
+            const v = this.bool(e.slice(1));
+            return v === null ? null : !v;
+        }
+        const isOr = /^([\s\S]+?)\s+is\s+("(?:[^"\\]|\\.)*"(?:\s+or\s+"(?:[^"\\]|\\.)*")*)$/.exec(e);
+        if (isOr) {
+            const v = this.str(isOr[1]);
+            const opts = [...isOr[2].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => m[1]);
+            return v === null ? null : opts.includes(v);
+        }
+        const eq = splitTop(e, ['==', '!=']);
+        if (eq.parts.length === 2) {
+            const a = this.value(eq.parts[0]);
+            const b = this.value(eq.parts[1]);
+            if (a.t === 'unknown' || b.t === 'unknown')
+                return null;
+            return same(a, b) === (eq.ops[0] === '==');
+        }
+        const rel = splitTop(e, ['<=', '>=', '<', '>']);
+        if (rel.parts.length === 2) {
+            const a = this.num(rel.parts[0]);
+            const b = this.num(rel.parts[1]);
+            if (a === null || b === null)
+                return null;
+            return rel.ops[0] === '<' ? a < b : rel.ops[0] === '>' ? a > b : rel.ops[0] === '<=' ? a <= b : a >= b;
+        }
+        const v = this.value(e);
+        return v.t === 'bool' ? v.v : null;
+    }
+    fieldOf(obj, name) {
+        const table = obj.t === 'imp' ? (this.kind === 'texture' ? TEXTURE_FIELDS : AUDIO_FIELDS) : obj.t === 'plat' ? PLATFORM_FIELDS : obj.t === 'adef' ? AUDIO_DEFAULT_FIELDS : obj.t === 'tset' ? TEXTURE_SETTINGS_FIELDS : null;
+        const f = table?.[name];
+        if (!f)
+            return null;
+        if (f.where === 'platform')
+            return obj.t === 'plat' && obj.target ? fieldId(obj.target, f.key) : null;
+        return fieldId(f.where, f.key);
+    }
+    convOf(id) {
+        const key = id.split('\u0000')[1];
+        const all = [...Object.values(TEXTURE_FIELDS), ...Object.values(PLATFORM_FIELDS), ...Object.values(AUDIO_FIELDS), ...Object.values(AUDIO_DEFAULT_FIELDS), ...Object.values(TEXTURE_SETTINGS_FIELDS)];
+        return all.find((f) => f.key === key)?.conv ?? 'num';
+    }
+    write(obj, name, rhs) {
+        const id = this.fieldOf(obj, name);
+        if (!id) {
+            if (obj.t === 'plat' && obj.target === null)
+                this.taintKey(PLATFORM_FIELDS[name]?.key);
+            return;
+        }
+        const v = this.murky ? UNKNOWN : this.value(rhs);
+        this.fields.set(id, v);
+    }
+    taintKey(key) {
+        if (!key)
+            return;
+        for (const id of this.fields.keys())
+            if (id.endsWith(`\u0000${key}`))
+                this.fields.set(id, UNKNOWN);
+        this.maybe.add(fieldId('*', key));
+    }
+    taintAll() {
+        for (const id of this.fields.keys())
+            this.fields.set(id, UNKNOWN);
+        this.any = true;
+    }
+    exec(stmts) {
+        for (const s of stmts) {
+            if (this.dead)
+                return;
+            this.stmt(s);
+        }
+    }
+    stmt(s) {
+        switch (s.k) {
+            case 'return':
+                if (s.text)
+                    this.ret = this.murky ? UNKNOWN : this.value(s.text);
+                this.dead = true;
+                return;
+            case 'if': {
+                const c = this.murky ? null : this.bool(s.cond);
+                if (c === true)
+                    return this.exec(s.then);
+                if (c === false)
+                    return this.exec(s.else);
+                const was = this.murky;
+                this.murky = true;
+                this.exec(s.then);
+                const d1 = this.dead;
+                this.dead = false;
+                this.exec(s.else);
+                const d2 = this.dead;
+                this.dead = false;
+                this.murky = was || d1 || d2;
+                return;
+            }
+            case 'foreach': {
+                const items = this.value(s.items);
+                if (items.t !== 'strs' || this.murky)
+                    return this.opaque(s.body.map(stmtText).join(';'), s.body);
+                for (const it of items.v) {
+                    this.vars.set(s.v, { t: 'str', v: it });
+                    this.exec(s.body);
+                    if (this.dead)
+                        return;
+                }
+                return;
+            }
+            case 'opaque':
+                return this.opaque(s.text, null);
+            case 'expr':
+                return this.expr(s.text);
+        }
+    }
+    opaque(text, body) {
+        void body;
+        for (const m of text.matchAll(/\b(\w+)\s*\.\s*(\w+)\s*=(?![=>])/g)) {
+            const v = this.vars.get(m[1]);
+            const id = v ? this.fieldOf(v, m[2]) : null;
+            if (id)
+                this.fields.set(id, UNKNOWN);
+            else
+                this.taintKey([TEXTURE_FIELDS, PLATFORM_FIELDS, AUDIO_FIELDS, AUDIO_DEFAULT_FIELDS].map((t) => t[m[2]]?.key).find(Boolean));
+        }
+        if (this.passesTracked(text))
+            this.taintAll();
+        if (/\breturn\b/.test(text))
+            this.murky = true;
+    }
+    passesTracked(text) {
+        const tracked = [...this.vars].filter(([, v]) => ['imp', 'plat', 'adef', 'tset'].includes(v.t)).map(([k]) => k);
+        return tracked.some((k) => new RegExp(`\\(\\s*(?:[^()]*,\\s*)?${k}\\b`).test(text)) || /\(\s*\(\s*(?:Texture|Audio)Importer\s*\)\s*assetImporter|\(\s*assetImporter\b/.test(text);
+    }
+    expr(text) {
+        const decl = /^(?:var|bool|string|int|float|double|[A-Z][\w.]*(?:<[^<>]*>)?)\s+(\w+\s*=[\s\S]+)$/.exec(text);
+        if (decl && !/^\w+\s*\./.test(text)) {
+            for (const part of splitTop(decl[1], [',']).parts) {
+                const m = /^\s*(\w+)\s*=\s*([\s\S]+)$/.exec(part);
+                if (m)
+                    this.vars.set(m[1], this.murky ? UNKNOWN : this.value(m[2]));
+            }
+            return;
+        }
+        const asg = /^([\w.]+)\s*=(?![=>])\s*([\s\S]+)$/.exec(text);
+        if (asg) {
+            const parts = asg[1].split('.');
+            if (parts.length === 1) {
+                this.vars.set(parts[0], this.murky ? UNKNOWN : this.value(asg[2]));
+                return;
+            }
+            const obj = parts.length === 2 ? this.vars.get(parts[0]) ?? (parts[0] === 'assetImporter' ? { t: 'imp' } : UNKNOWN) : UNKNOWN;
+            if (obj.t !== 'unknown')
+                return this.write(obj, parts[parts.length - 1], asg[2]);
+            return;
+        }
+        const call = /^([\w.]+)\s*\(([\s\S]*)\)$/.exec(text);
+        if (call) {
+            const parts = call[1].split('.');
+            const args = splitTop(call[2], [',']).parts.filter((a) => a.trim());
+            if (parts.length === 2 && this.vars.get(parts[0])?.t === 'imp') {
+                if (parts[1] === 'ClearPlatformTextureSettings')
+                    this.taintKey('overridden');
+                return;
+            }
+            if (parts.length === 1 && this.methods.has(parts[0])) {
+                const m = this.methods.get(parts[0]).find((x) => x.params.length === args.length);
+                if (m && m.expr === null) {
+                    const bound = args.map((a) => this.value(a));
+                    const saved = { vars: this.vars, ret: this.ret, dead: this.dead, murky: this.murky };
+                    this.vars = new Map([['assetPath', saved.vars.get('assetPath') ?? UNKNOWN]]);
+                    m.params.forEach((p, i) => this.vars.set(p, bound[i]));
+                    this.depth++;
+                    try {
+                        if (this.depth <= 6)
+                            this.exec(m.body);
+                        else
+                            this.taintAll();
+                    }
+                    finally {
+                        this.depth--;
+                        this.vars = saved.vars;
+                        this.ret = saved.ret;
+                        this.dead = saved.dead;
+                        this.murky = saved.murky;
+                    }
+                    return;
+                }
+            }
+            if (this.passesTracked(text))
+                this.taintAll();
+            return;
+        }
+        if (this.passesTracked(text))
+            this.taintAll();
+    }
+    wants() {
+        const out = [];
+        for (const [id, v] of this.fields) {
+            if (v.t === 'unknown')
+                continue;
+            const [where, key] = id.split('\u0000');
+            const conv = this.convOf(id);
+            let value = null;
+            let shown = '';
+            if (conv === 'bool') {
+                if (v.t === 'bool') {
+                    value = v.v ? '1' : '0';
+                    shown = String(v.v);
+                }
+            }
+            else if (conv === 'num') {
+                if (v.t === 'num') {
+                    value = String(v.v);
+                    shown = String(v.v);
+                }
+                else if (v.t === 'enum' && ENUMS[v.type]?.[v.member] !== undefined) {
+                    value = String(ENUMS[v.type][v.member]);
+                    shown = v.member;
+                }
+            }
+            else if (v.t === 'enum' && v.type === conv && ENUMS[conv][v.member] !== undefined) {
+                value = String(ENUMS[conv][v.member]);
+                shown = v.member;
+            }
+            else if (v.t === 'num' && ENUMS[conv]) {
+                value = String(v.v);
+                shown = enumName(conv, value);
+            }
+            if (value !== null)
+                out.push({ where, key, value, shown });
+        }
+        return out;
+    }
+}
+const stmtText = (s) => (s.k === 'expr' || s.k === 'opaque' ? s.text : s.k === 'return' ? `return ${s.text}` : s.k === 'if' ? `if (${s.cond}) {${s.then.map(stmtText).join(';')}} else {${s.else.map(stmtText).join(';')}}` : `foreach (${s.v} in ${s.items}) {${s.body.map(stmtText).join(';')}}`);
+function splitChain(e) {
+    const out = [];
+    let i = 0;
+    while (i < e.length) {
+        const m = /^\s*([A-Za-z_]\w*)\s*/.exec(e.slice(i));
+        if (!m)
+            return null;
+        i += m[0].length;
+        let args = null;
+        if (e[i] === '(') {
+            const end = skipGroup(e, i);
+            const inner = e.slice(i + 1, end - 1);
+            args = inner.trim() ? splitTop(inner, [',']).parts.map((a) => a.trim()) : [];
+            i = end;
+            while (e[i] === ' ')
+                i++;
+        }
+        out.push({ name: m[1], args });
+        if (i >= e.length)
+            break;
+        if (e[i] !== '.')
+            return null;
+        i++;
+    }
+    return out.length ? out : null;
+}
+const PREPROCESS = { OnPreprocessTexture: 'texture', OnPreprocessAudio: 'audio' };
+export function importRules(files) {
+    const scope = ruleScope(files);
+    const rules = [];
+    for (const f of files) {
+        if (!/\bAssetPostprocessor\b/.test(f.code))
+            continue;
+        const posts = new Set([...f.code.matchAll(/\bclass\s+(\w+)\s*:\s*(?:UnityEditor\.)?AssetPostprocessor\b/g)].map((m) => m[1]));
+        if (!posts.size)
+            continue;
+        const methods = methodsIn(f.withStrings, f.code);
+        const classes = [...f.code.matchAll(/\b(?:class|struct)\s+(\w+)[^{;]*\{/g)].map((c) => ({ name: c[1], start: c.index + c[0].length - 1, end: skipGroup(f.code, c.index + c[0].length - 1) }));
+        const ownerOf = (at) => classes.filter((c) => c.start < at && at < c.end).sort((a, b) => b.start - a.start)[0]?.name;
+        const owners = methodsOf(f.code);
+        for (const [name, kind] of Object.entries(PREPROCESS)) {
+            for (const [i, m] of (methods.get(name) ?? []).entries()) {
+                if (m.params.length)
+                    continue;
+                const cls = ownerOf(owners.filter((o) => o.name === name)[i]?.start ?? -1);
+                if (!cls || !posts.has(cls))
+                    continue;
+                const memo = new Map();
+                const run = (path) => {
+                    const r = new Run(scope, methods, kind, f.rel, cls);
+                    r.vars.set('assetPath', { t: 'str', v: path });
+                    r.vars.set('assetImporter', { t: 'imp' });
+                    try {
+                        r.exec(m.body);
+                    }
+                    catch {
+                        return { wants: [], maybe: new Set(), any: true };
+                    }
+                    const maybe = new Set(r.maybe);
+                    for (const [id, v] of r.fields)
+                        if (v.t === 'unknown')
+                            maybe.add(id);
+                    return { wants: r.wants(), maybe, any: r.any };
+                };
+                rules.push({
+                    name: `${cls}.${name}`,
+                    file: f.rel,
+                    kind,
+                    read: (path) => {
+                        let out = memo.get(path);
+                        if (!out)
+                            memo.set(path, (out = run(path)));
+                        return out;
+                    },
+                });
+            }
+        }
+    }
+    return rules;
+}