Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import type { JsonValue } from "../jsonValue.js";
/** Source element types needed to distinguish large integers from integral reals. */
export interface PlistNumberLiterals {
readonly integers: ReadonlyMap<number, ReadonlySet<string>>;
readonly reals: ReadonlySet<number>;
/** Integer literals in the original serialized plist, not decoded graph slots. */
readonly unsafeIntegerLiterals: number;
/** Source numeric facts could not all be established. */
readonly incomplete: boolean;
}
export const incompletePlistNumberLimitation =
"Property-list number metadata could not be completely observed; decoded numbers may lose integer precision and exact integer/real association is unavailable.";
/** Collect facts at the decoder boundary before integer values are rounded. */
export const createPlistNumberCollector = () => {
const integers = new Map<number, Set<string>>();
const reals = new Set<number>();
let unsafeIntegerLiterals = 0;
return {
integer: (exact: bigint) => {
if (
exact >= BigInt(Number.MIN_SAFE_INTEGER) &&
exact <= BigInt(Number.MAX_SAFE_INTEGER)
)
return;
unsafeIntegerLiterals++;
const rounded = Number(exact);
integers.set(
rounded,
(integers.get(rounded) ?? new Set()).add(exact.toString()),
);
},
real: (value: number) => {
reals.add(value);
},
result: (incomplete = false): PlistNumberLiterals => ({
integers,
reals,
unsafeIntegerLiterals,
incomplete,
}),
};
};
/** Preserve unambiguous exact integers; disclose rounded or unclassified numbers. */
export const createPlistNumberProjection = (literals: PlistNumberLiterals) => {
let exactIntegerCount = 0;
let ambiguousNumberCount = 0;
const mapNumber = (item: number): JsonValue => {
if (Number.isSafeInteger(item) || !Number.isInteger(item)) return item;
if (literals.incomplete) {
ambiguousNumberCount += 1;
return item;
}
const decimals = literals.integers.get(item);
if (decimals === undefined) {
if (!literals.reals.has(item)) ambiguousNumberCount += 1;
return item;
}
const [decimal] = decimals;
if (
decimals.size !== 1 ||
decimal === undefined ||
literals.reals.has(item)
) {
ambiguousNumberCount += 1;
return item;
}
exactIntegerCount += 1;
return { $plist_type: "integer", decimal };
};
const map = (item: JsonValue): JsonValue => {
if (typeof item === "number") return mapNumber(item);
if (Array.isArray(item)) return item.map(map);
if (item !== null && typeof item === "object") {
const keys = Object.keys(item);
const marker = item[keys[0] ?? ""];
const reference =
keys.length === 1 &&
(keys[0] === "UID" || keys[0] === "CF$UID") &&
typeof marker === "number";
if (reference) {
// Keep malformed numeric reference markers recognizable by the graph reader.
if (
typeof marker === "number" &&
!Number.isSafeInteger(marker) &&
(literals.integers.has(marker) || !literals.reals.has(marker))
)
ambiguousNumberCount += 1;
return item;
}
return Object.fromEntries(
Object.entries(item).map(([key, child]) => [key, map(child)]),
);
}
return item;
};
return {
project: map,
limitations: () => [
...(literals.incomplete ? [incompletePlistNumberLimitation] : []),
...(literals.unsafeIntegerLiterals === 0
? []
: [
`${String(literals.unsafeIntegerLiterals)} observed integer literal(s) in the original archive exceed the exact range of a JSON number. Decoded numbers may lose integer precision unless represented as { "$plist_type": "integer", "decimal": "<exact digits>" }; the original archive bytes retain those literals.`,
]),
...(exactIntegerCount === 0
? []
: [
`${String(exactIntegerCount)} unambiguous integer value(s) are reported with exact decimal text as { "$plist_type": "integer", "decimal": "<exact digits>" }.`,
]),
...(ambiguousNumberCount === 0
? []
: [
`${String(ambiguousNumberCount)} number(s) beyond the exact integer range remain as decoded because their source integer/real type or reference marker cannot be associated unambiguously; integer precision loss remains possible.`,
]),
],
};
};