Daan MeijerandClaude Opus 5.5
4ed7f89951
Lone candidates are often par2 volumes of random-named sets
("42507096….vol007+08.par2"): their yEnc name was taken as the inner
name. Packaging names are skipped for lone files too, and a name that
starts with the release's own name says nothing new.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
84 lines
3.8 KiB
TypeScript
84 lines
3.8 KiB
TypeScript
import { decodeSegment, YencCrcError, YencError, type DecodedSegment } from '#lib/yenc/index'
|
|
import { isPar2, parsePar2 } from '#lib/par2/index'
|
|
import { parseRarHeaders } from '#lib/rar/index'
|
|
import { sniffContentType, type ContentType } from '#lib/content/index'
|
|
|
|
/** What one probed article showed (REBUILD.md, part 6; stored per release and kind). */
|
|
export interface Inspection {
|
|
/** The file name in the yEnc header. */
|
|
yencName: string
|
|
/** The whole file's size, from the yEnc header. */
|
|
size: number
|
|
type: ContentType | null
|
|
/** Names inside: an archive's entries or a par2 set's files, the largest first, at most MAX_NAMES. */
|
|
names?: string[]
|
|
/** How many entries or files there are in all. */
|
|
entries?: number
|
|
/** An archive with encrypted entries or headers. */
|
|
passworded?: boolean
|
|
}
|
|
|
|
/** Names kept per inspection: the catalog wants the content's name, not every volume's. */
|
|
export const MAX_NAMES = 8
|
|
const MAX_NAME_LENGTH = 200
|
|
|
|
/** Archive volumes, par2 volumes and split parts: names of the packaging, not the content. */
|
|
const PACKAGING = /\.(rar|r\d{2,3}|s\d{2}|\d{3}|7z(\.\d+)?|zip|z\d{2}|par2|sfv|nfo|nzb)$/i
|
|
|
|
/** Decodes a body; some tools declare a size that leaves out a header, the CRC still has to match. */
|
|
function decodeBody(body: Buffer): DecodedSegment {
|
|
try {
|
|
return decodeSegment(body)
|
|
} catch (error) {
|
|
if (!(error instanceof YencError) || error instanceof YencCrcError) throw error
|
|
return decodeSegment(body, { lenientSize: true })
|
|
}
|
|
}
|
|
|
|
function largestFirst(items: { name: string; size: number }[]): string[] {
|
|
return items
|
|
.sort((a, b) => b.size - a.size)
|
|
.slice(0, MAX_NAMES)
|
|
.map((i) => i.name.slice(0, MAX_NAME_LENGTH))
|
|
}
|
|
|
|
/** One article's body: its yEnc header, what the first bytes are, and for par2 and RAR what's inside. Throws when it isn't yEnc. */
|
|
export function inspect(body: Buffer): Inspection {
|
|
const segment = decodeBody(body)
|
|
const result: Inspection = { yencName: segment.meta.begin.name.slice(0, MAX_NAME_LENGTH), size: segment.meta.begin.size, type: sniffContentType(segment.data) }
|
|
if (isPar2(segment.data)) {
|
|
// An index file fits one article; what a larger one cut off is skipped by the parser.
|
|
const set = parsePar2(segment.data)
|
|
if (set) {
|
|
result.entries = set.files.length
|
|
result.names = largestFirst(set.files.map((f) => ({ name: f.name, size: f.length })))
|
|
}
|
|
return result
|
|
}
|
|
if (result.type === 'rar4' || result.type === 'rar5') {
|
|
const info = parseRarHeaders(segment.data)
|
|
if (info) {
|
|
const files = info.entries.filter((e) => !e.directory)
|
|
result.entries = files.length
|
|
result.names = largestFirst(files.map((e) => ({ name: e.name, size: Number(e.size ?? 0) })))
|
|
result.passworded = info.headersEncrypted || files.some((e) => e.encrypted)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* A release's best inner name from its inspections (by probe kind): the
|
|
* largest named entry of an archive, else the largest file of a par2 set
|
|
* that isn't packaging, else a lone file's yEnc name. Null when none says
|
|
* more than the release's own name.
|
|
*/
|
|
export function innerName(inspections: { kind: string; result: Inspection }[], releaseName = ''): string | null {
|
|
const of = (kind: string) => inspections.filter((i) => i.kind === kind).map((i) => i.result)
|
|
const content = (kind: string) => of(kind).flatMap((i) => i.names ?? []).find((n) => !PACKAGING.test(n))
|
|
const pick = content('archive') ?? content('par2') ?? of('lone').find((i) => i.yencName && !PACKAGING.test(i.yencName))?.yencName
|
|
const name = pick?.replace(/^.*[\\/]/, '').slice(0, 255)
|
|
// The release's own name with an extension says nothing new (a random-named file's yEnc name is mostly its random name).
|
|
return name && !name.toLowerCase().startsWith(releaseName.toLowerCase() || '\0') ? name : null
|
|
}
|