@peekling/runtime 0.1.0

package/dist/own-data.js

@@ -0,0 +1,205 @@
+import { runtimeMessage } from "./runtime-diagnostics.js";
+export class OwnDataError extends TypeError {
+    issueCode;
+    constructor(path, reason, issueCode) {
+        super(`${path} ${reason}`);
+        this.name = "OwnDataError";
+        this.issueCode = issueCode;
+    }
+}
+const trustedConfigurations = new WeakSet();
+const trustedOwnData = new WeakSet();
+const trustedPackData = new WeakSet();
+function plain(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.prototype;
+}
+function trusted(input, mode) {
+    if (typeof input !== "object" || input === null)
+        return false;
+    if (mode === "configuration") {
+        return trustedConfigurations.has(input) || trustedOwnData.has(input);
+    }
+    return mode === "pack"
+        ? trustedPackData.has(input)
+        : trustedOwnData.has(input);
+}
+function mark(value, ownSafe, packSafe) {
+    if (ownSafe)
+        trustedOwnData.add(value);
+    if (packSafe)
+        trustedPackData.add(value);
+}
+function snapshotData(input, mode, policy) {
+    if (!policy && trusted(input, mode))
+        return input;
+    let nodes = 0;
+    let values = 0;
+    const active = new WeakSet();
+    const clones = new WeakMap();
+    const fail = (path, issueCode, detail) => {
+        throw new OwnDataError(path, runtimeMessage(issueCode, detail), issueCode);
+    };
+    const visit = (value, path, depth) => {
+        if (policy?.maxDepth !== undefined && depth > policy.maxDepth) {
+            return fail(path, "data.depth", "exceeds maximum depth");
+        }
+        values += 1;
+        if (policy?.maxValues !== undefined && values > policy.maxValues) {
+            return fail(path, "data.nodes", "exceeds maximum object count");
+        }
+        if (value === null || typeof value === "boolean") {
+            return { value, ownSafe: true, packSafe: true };
+        }
+        if (typeof value === "string") {
+            if (policy?.maxStringLength !== undefined &&
+                value.length > policy.maxStringLength) {
+                return fail(path, "data.string", "exceeds maximum string length");
+            }
+            return { value, ownSafe: true, packSafe: true };
+        }
+        if (typeof value === "number") {
+            if (policy?.json && !Number.isFinite(value)) {
+                return fail(path, "data.type", "contains unsupported data");
+            }
+            return { value, ownSafe: true, packSafe: true };
+        }
+        if (typeof value === "undefined") {
+            if (policy?.json) {
+                return fail(path, "data.type", "contains unsupported data");
+            }
+            return { value, ownSafe: true, packSafe: true };
+        }
+        if (typeof value === "function") {
+            if (mode === "pack" || policy?.json) {
+                return fail(path, "data.type", "contains unsupported data");
+            }
+            return { value, ownSafe: true, packSafe: false };
+        }
+        if (typeof value !== "object") {
+            return fail(path, "data.type", "contains unsupported data");
+        }
+        if (mode === "configuration" &&
+            (path === "$.document" || path === "$.window")) {
+            return { value, ownSafe: false, packSafe: false };
+        }
+        if (depth > 32)
+            return fail(path, "data.depth", "exceeds maximum depth");
+        nodes += 1;
+        if (nodes > 20_000)
+            return fail(path, "data.nodes", "exceeds maximum object count");
+        const previous = clones.get(value);
+        if (previous) {
+            if (active.has(value)) {
+                return fail(path, "data.cycle", "must not contain cycles");
+            }
+            if (!policy) {
+                return {
+                    value: previous.value,
+                    ownSafe: previous.ownSafe,
+                    packSafe: previous.packSafe,
+                };
+            }
+        }
+        let keys;
+        try {
+            keys = Reflect.ownKeys(value);
+        }
+        catch {
+            return fail(path, "data.reflect", "cannot be inspected safely");
+        }
+        if (keys.some((key) => typeof key !== "string")) {
+            return fail(path, "data.symbol", "contains symbol properties");
+        }
+        if (Array.isArray(value)) {
+            if (value.length > Math.min(4_096, policy?.maxArrayLength ?? 4_096))
+                return fail(path, "data.array", "exceeds maximum array length");
+            if (keys.length !== value.length + 1 ||
+                keys.some((key) => key !== "length" &&
+                    (!/^\d+$/.test(key) || Number(key) >= value.length)))
+                return fail(path, "data.array-own", "contains custom array properties");
+            const output = [];
+            const record = { value: output };
+            clones.set(value, record);
+            active.add(value);
+            let ownSafe = true;
+            let packSafe = true;
+            for (let index = 0; index < value.length; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (!descriptor || descriptor.get || descriptor.set) {
+                    return fail(`${path}[${index}]`, "data.descriptor", "must be an own data property");
+                }
+                const item = visit(descriptor.value, `${path}[${index}]`, depth + 1);
+                output.push(item.value);
+                ownSafe &&= item.ownSafe;
+                packSafe &&= item.packSafe;
+            }
+            active.delete(value);
+            const frozen = Object.freeze(output);
+            record.ownSafe = ownSafe;
+            record.packSafe = packSafe;
+            mark(frozen, ownSafe, packSafe);
+            return { value: frozen, ownSafe, packSafe };
+        }
+        let isPlain;
+        try {
+            isPlain = plain(value);
+        }
+        catch {
+            return fail(path, "data.reflect", "cannot be inspected safely");
+        }
+        if (!isPlain)
+            return fail(path, "data.plain", "must use this realm's Object prototype or a null prototype");
+        if (keys.length > Math.min(1_024, policy?.maxObjectKeys ?? 1_024))
+            return fail(path, "data.keys", "exceeds maximum property count");
+        const output = Object.create(null);
+        const record = { value: output };
+        clones.set(value, record);
+        active.add(value);
+        let ownSafe = true;
+        let packSafe = true;
+        for (const key of keys) {
+            if (policy?.key && !policy.key(key)) {
+                fail(`${path}.${key}`, "data.key", "contains an invalid property name");
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || descriptor.get || descriptor.set) {
+                return fail(`${path}.${key}`, "data.descriptor", "must be an own data property");
+            }
+            const item = visit(descriptor.value, `${path}.${key}`, depth + 1);
+            output[key] = item.value;
+            ownSafe &&= item.ownSafe;
+            packSafe &&= item.packSafe;
+        }
+        active.delete(value);
+        const frozen = Object.freeze(output);
+        record.ownSafe = ownSafe;
+        record.packSafe = packSafe;
+        mark(frozen, ownSafe, packSafe);
+        return { value: frozen, ownSafe, packSafe };
+    };
+    try {
+        const result = visit(input, "$", 0);
+        if (mode === "configuration" &&
+            typeof result.value === "object" &&
+            result.value !== null) {
+            trustedConfigurations.add(result.value);
+        }
+        return result.value;
+    }
+    catch (cause) {
+        if (cause instanceof OwnDataError)
+            throw cause;
+        return fail("$", "data.reflect", "cannot be inspected safely");
+    }
+}
+export function snapshotOwnData(input, policy) {
+    return snapshotData(input, "own", policy);
+}
+/** Shared package-family boundary for data-only Pack and adapter input. */
+export function snapshotPackData(input) {
+    return snapshotData(input, "pack");
+}
+export function snapshotConfiguration(input) {
+    return snapshotData(input, "configuration");
+}

package/dist/pack-api.d.ts

@@ -0,0 +1,9 @@
+export { PackValidationError } from "./errors.js";
+export { parseDataText } from "./json.js";
+export { snapshotPackData } from "./own-data.js";
+export { parseManifestText, validateNativePack } from "./pack.js";
+export { inspectImageStructure } from "./pack-shared.js";
+export { validateNormalizedPack } from "./normalized.js";
+export type { ImageMimeType, ImageStructure } from "./pack-shared.js";
+export type { AtlasGeometry, Direction, NativeDensity, NativeManifest, NormalizedPack, StateDefinition, } from "./types.js";
+//# sourceMappingURL=pack-api.d.ts.map

package/dist/pack-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-api.d.ts","sourceRoot":"","sources":["../src/pack-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/dist/pack-api.js

@@ -0,0 +1,6 @@
+export { PackValidationError } from "./errors.js";
+export { parseDataText } from "./json.js";
+export { snapshotPackData } from "./own-data.js";
+export { parseManifestText, validateNativePack } from "./pack.js";
+export { inspectImageStructure } from "./pack-shared.js";
+export { validateNormalizedPack } from "./normalized.js";

package/dist/pack-shared.d.ts

@@ -0,0 +1,28 @@
+import type { NormalizedPack, StateDefinition } from "./types.js";
+export declare const SHA256_PATTERN: RegExp;
+type AtlasVariant = NonNullable<NormalizedPack["atlas"]["variants"]>[number];
+export declare function validateSha256(value: unknown, path: string, issues: string[]): value is string;
+export declare function validateDensityVariants(input: unknown, options: {
+    path: string;
+    logicalWidth?: number;
+    logicalHeight?: number;
+    native?: boolean;
+}, issues: string[]): AtlasVariant[];
+export declare function validateStateMap(input: unknown, cellCount: number, issues: string[]): Record<string, StateDefinition>;
+export declare function validateMotionKeyframes(input: unknown, path: string, issues: string[]): Array<{
+    at: number;
+    advance: number;
+    lift: number;
+}>;
+export declare function record(value: unknown): value is Record<string, unknown>;
+export declare function closed(value: Record<string, unknown>, allowed: readonly string[], path: string, issues: string[]): void;
+export type ImageMimeType = "image/png" | "image/webp";
+export interface ImageStructure {
+    readonly width: number;
+    readonly height: number;
+    readonly hasAlpha: boolean;
+    readonly mimeType: ImageMimeType;
+}
+export declare function inspectImageStructure(bytes: Uint8Array, mimeType: ImageMimeType): ImageStructure;
+export {};
+//# sourceMappingURL=pack-shared.d.ts.map

package/dist/pack-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-shared.d.ts","sourceRoot":"","sources":["../src/pack-shared.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlE,eAAO,MAAM,cAAc,QAAmB,CAAC;AAE/C,KAAK,YAAY,GAAG,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,GACf,KAAK,IAAI,MAAM,CAQjB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;IACP,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,EACD,MAAM,EAAE,MAAM,EAAE,GACf,YAAY,EAAE,CA8EhB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EAAE,GACf,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CA6FjC;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,GACf,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAwDtD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEvE;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,GACf,IAAI,CAMN;AAOD,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,YAAY,CAAC;AAEvD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;CAClC;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,aAAa,GACtB,cAAc,CAahB"}

package/dist/pack-shared.js

@@ -0,0 +1,408 @@
+import { ASSET_PATH_PATTERN, STATE_NAME_PATTERN } from "./contracts.js";
+import { addPackIssue, throwPackIssue } from "./errors.js";
+const MIN_STATE_FPS = 0.1;
+export const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+export function validateSha256(value, path, issues) {
+    if (typeof value === "string" && SHA256_PATTERN.test(value))
+        return true;
+    addPackIssue(issues, path, `${path} must be 64 lowercase hexadecimal characters`);
+    return false;
+}
+export function validateDensityVariants(input, options, issues) {
+    const result = [];
+    if (!Array.isArray(input) || input.length < 1 || input.length > 3) {
+        addPackIssue(issues, `${options.path}.limit`, `${options.path} must contain 1-3 variants`);
+        return result;
+    }
+    const seen = new Set();
+    for (const [index, value] of input.entries()) {
+        const path = `${options.path}.${index}`;
+        if (!record(value)) {
+            addPackIssue(issues, path, `${path} must be an object`);
+            continue;
+        }
+        closed(value, options.native
+            ? ["src", "density", "sourceCellSize", "sha256"]
+            : ["src", "density", "cellWidth", "cellHeight", "sha256"], path, issues);
+        const density = value.density;
+        const validDensity = (density === 1 || density === 2 || density === 4) && !seen.has(density);
+        const src = value.src;
+        const validSource = typeof src === "string" &&
+            ASSET_PATH_PATTERN.test(src) &&
+            (options.native ? /\.png$/i : /\.(?:png|webp)$/i).test(src);
+        const sha256 = value.sha256;
+        const validHash = validateSha256(sha256, `${path}.sha256`, issues);
+        const cellWidth = options.native
+            ? Number(options.logicalWidth) * Number(density)
+            : value.cellWidth;
+        const cellHeight = options.native
+            ? Number(options.logicalHeight) * Number(density)
+            : value.cellHeight;
+        const validDimensions = options.native
+            ? value.sourceCellSize === cellWidth && cellWidth === cellHeight
+            : Number.isInteger(cellWidth) &&
+                cellWidth >= 1 &&
+                cellWidth <= 1_024 &&
+                Number.isInteger(cellHeight) &&
+                cellHeight >= 1 &&
+                cellHeight <= 1_024;
+        if (!validDimensions) {
+            addPackIssue(issues, `${path}.dimensions`, options.native
+                ? `${path}.sourceCellSize does not match density`
+                : `${path} has invalid cell dimensions`);
+            continue;
+        }
+        if (!validDensity || !validSource) {
+            addPackIssue(issues, `${path}.density`, `${path} has invalid or duplicate density data`);
+            continue;
+        }
+        if (!validHash)
+            continue;
+        seen.add(density);
+        result.push({
+            src,
+            density,
+            cellWidth: cellWidth,
+            cellHeight: cellHeight,
+            sha256,
+        });
+    }
+    return result.sort((left, right) => left.density - right.density);
+}
+export function validateStateMap(input, cellCount, issues) {
+    const states = Object.create(null);
+    if (!record(input)) {
+        addPackIssue(issues, "states", "states must be an object");
+        return states;
+    }
+    const entries = Object.entries(input);
+    if (entries.length === 0 || entries.length > 64) {
+        addPackIssue(issues, "states.limit", "states must contain 1-64 entries");
+    }
+    for (const [name, value] of entries) {
+        const path = `states.${name}`;
+        if (!STATE_NAME_PATTERN.test(name) ||
+            ["constructor", "prototype", "__proto__"].includes(name) ||
+            !record(value)) {
+            addPackIssue(issues, path, `${path} is invalid`);
+            continue;
+        }
+        closed(value, ["frames", "fps", "loop", "durations"], path, issues);
+        const frames = value.frames;
+        const durations = value.durations;
+        if (!Array.isArray(frames) ||
+            frames.length === 0 ||
+            frames.length > 64 ||
+            frames.some((frame) => !Number.isInteger(frame) || frame < 0 || frame >= cellCount)) {
+            addPackIssue(issues, `${path}.frames`, `${path}.frames must contain 1-64 in-bounds integers`);
+            continue;
+        }
+        const hasFps = value.fps !== undefined;
+        const hasDurations = durations !== undefined;
+        const fpsValid = typeof value.fps === "number" &&
+            Number.isFinite(value.fps) &&
+            value.fps >= MIN_STATE_FPS &&
+            value.fps <= 60;
+        const durationsValid = Array.isArray(durations) &&
+            durations.length === frames.length &&
+            durations.every((duration) => typeof duration === "number" &&
+                Number.isFinite(duration) &&
+                duration >= 16 &&
+                duration <= 10_000) &&
+            durations.reduce((sum, duration) => sum + duration, 0) <=
+                60_000;
+        if (hasFps === hasDurations ||
+            typeof value.loop !== "boolean" ||
+            (hasFps && !fpsValid) ||
+            (hasDurations && !durationsValid)) {
+            addPackIssue(issues, `${path}.timing`, hasDurations && !durationsValid
+                ? `${path}.durations must match frames and be bounded`
+                : hasFps && !fpsValid
+                    ? `${path}.fps must be >=${MIN_STATE_FPS} and <=60`
+                    : `${path} needs boolean loop and one of fps or durations`);
+            continue;
+        }
+        states[name] = hasFps
+            ? {
+                frames: [...frames],
+                loop: value.loop,
+                fps: value.fps,
+            }
+            : {
+                frames: [...frames],
+                loop: value.loop,
+                durations: [...durations],
+            };
+    }
+    if (!states.idle) {
+        addPackIssue(issues, "states.idle", "states.idle is required");
+    }
+    return states;
+}
+export function validateMotionKeyframes(input, path, issues) {
+    const result = [];
+    if (!Array.isArray(input) || input.length < 2 || input.length > 8) {
+        addPackIssue(issues, `${path}.limit`, `${path} needs 2-8 keyframes`);
+        return result;
+    }
+    for (const [index, value] of input.entries()) {
+        const itemPath = `${path}.${index}`;
+        const previous = result.at(-1);
+        if (record(value)) {
+            closed(value, ["at", "advance", "lift"], itemPath, issues);
+        }
+        if (!record(value) ||
+            !Number.isFinite(value.at) ||
+            !Number.isFinite(value.advance) ||
+            !Number.isFinite(value.lift) ||
+            value.at < 0 ||
+            value.at > 1 ||
+            value.advance < 0 ||
+            value.advance > 1 ||
+            value.lift < 0 ||
+            value.lift > 0.5 ||
+            (previous !== undefined &&
+                (value.at <= previous.at ||
+                    value.advance < previous.advance))) {
+            addPackIssue(issues, itemPath, `${itemPath} needs increasing at and bounded motion values`);
+            continue;
+        }
+        result.push({
+            at: value.at,
+            advance: value.advance,
+            lift: value.lift,
+        });
+    }
+    if (result.length === input.length &&
+        (result[0].at !== 0 ||
+            result[0].advance !== 0 ||
+            result[0].lift !== 0 ||
+            result.at(-1).at !== 1 ||
+            result.at(-1).advance !== 1 ||
+            result.at(-1).lift !== 0)) {
+        addPackIssue(issues, `${path}.endpoints`, `${path} endpoints must be 0/0/0 and 1/1/0`);
+    }
+    return result;
+}
+export function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function closed(value, allowed, path, issues) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key)) {
+            addPackIssue(issues, `${path}.${key}`, `${path}.${key} is not allowed`);
+        }
+    }
+}
+const MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+const MAX_IMAGE_SIDE = 4_096;
+const MAX_IMAGE_CHUNKS = 4_096;
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+export function inspectImageStructure(bytes, mimeType) {
+    if (bytes.byteLength > MAX_IMAGE_BYTES) {
+        throwPackIssue("resource.size", "Image exceeds 32 MiB");
+    }
+    const png = hasPngSignature(bytes);
+    const webp = hasWebpSignature(bytes);
+    if ((mimeType === "image/png" && webp) ||
+        (mimeType === "image/webp" && png)) {
+        throwPackIssue("atlas.mime", "Content-Type does not match atlas bytes");
+    }
+    return mimeType === "image/png" ? inspectPng(bytes) : inspectWebp(bytes);
+}
+function hasPngSignature(bytes) {
+    return PNG_SIGNATURE.every((byte, index) => bytes[index] === byte);
+}
+function hasWebpSignature(bytes) {
+    return (bytes.byteLength >= 12 &&
+        chunkName(bytes, 0) === "RIFF" &&
+        chunkName(bytes, 8) === "WEBP");
+}
+function chunkName(bytes, offset) {
+    return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function inspectPng(bytes) {
+    if (!hasPngSignature(bytes)) {
+        throwPackIssue("png.signature", "Invalid PNG signature");
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = PNG_SIGNATURE.length;
+    let width = 0;
+    let height = 0;
+    let colorType = -1;
+    let chunks = 0;
+    let sawHeader = false;
+    let sawPalette = false;
+    let sawTransparency = false;
+    let sawData = false;
+    while (offset < bytes.byteLength) {
+        if (bytes.byteLength - offset < 12) {
+            throwPackIssue("png.truncated", "PNG is truncated");
+        }
+        const length = view.getUint32(offset);
+        const dataOffset = offset + 8;
+        const next = dataOffset + length + 4;
+        if (next > bytes.byteLength || next < dataOffset) {
+            throwPackIssue("png.chunk", "PNG chunk is truncated");
+        }
+        const type = chunkName(bytes, offset + 4);
+        if (!/^[A-Za-z]{4}$/.test(type)) {
+            throwPackIssue("png.chunk-type", "PNG chunk type is invalid");
+        }
+        chunks += 1;
+        if (chunks > MAX_IMAGE_CHUNKS) {
+            throwPackIssue("png.chunks", "PNG has too many chunks");
+        }
+        if (!sawHeader && (type !== "IHDR" || length !== 13)) {
+            throwPackIssue("png.ihdr-first", "PNG must start with a 13-byte IHDR");
+        }
+        if (type === "IHDR") {
+            if (sawHeader || length !== 13) {
+                throwPackIssue("png.ihdr", "PNG has an invalid IHDR");
+            }
+            sawHeader = true;
+            width = view.getUint32(dataOffset);
+            height = view.getUint32(dataOffset + 4);
+            const bitDepth = bytes[dataOffset + 8];
+            colorType = bytes[dataOffset + 9];
+            const allowedDepths = {
+                0: [1, 2, 4, 8, 16],
+                2: [8, 16],
+                3: [1, 2, 4, 8],
+                4: [8, 16],
+                6: [8, 16],
+            };
+            if (width < 1 ||
+                height < 1 ||
+                width > MAX_IMAGE_SIDE ||
+                height > MAX_IMAGE_SIDE) {
+                throwPackIssue("png.dimensions", `PNG dimensions must be 1-${MAX_IMAGE_SIDE} per side`);
+            }
+            if (!allowedDepths[colorType]?.includes(bitDepth) ||
+                bytes[dataOffset + 10] !== 0 ||
+                bytes[dataOffset + 11] !== 0 ||
+                (bytes[dataOffset + 12] !== 0 && bytes[dataOffset + 12] !== 1)) {
+                throwPackIssue("png.fields", "PNG IHDR fields are invalid");
+            }
+        }
+        else if (type === "PLTE") {
+            if (sawData) {
+                throwPackIssue("png.palette-order", "PNG palette is misplaced");
+            }
+            sawPalette = true;
+        }
+        else if (type === "tRNS") {
+            if (sawData) {
+                throwPackIssue("png.alpha-order", "PNG transparency is misplaced");
+            }
+            sawTransparency = true;
+        }
+        else if (type === "IDAT") {
+            if (colorType === 3 && !sawPalette) {
+                throwPackIssue("png.palette", "Indexed PNG requires a palette");
+            }
+            sawData = true;
+        }
+        else if (type === "IEND") {
+            if (length !== 0 || !sawData) {
+                throwPackIssue("png.iend", "PNG has an invalid IEND");
+            }
+            if (next !== bytes.byteLength) {
+                throwPackIssue("png.trailing", "PNG has trailing bytes");
+            }
+            return {
+                width,
+                height,
+                hasAlpha: colorType === 4 ||
+                    colorType === 6 ||
+                    (colorType === 3 && sawTransparency),
+                mimeType: "image/png",
+            };
+        }
+        else if (type.charCodeAt(0) <= 0x5a) {
+            throwPackIssue("png.critical", `PNG contains unsupported critical chunk ${type}`);
+        }
+        offset = next;
+    }
+    throwPackIssue("png.truncated", "PNG is truncated");
+}
+function inspectWebp(bytes) {
+    if (bytes.byteLength < 20 || !hasWebpSignature(bytes)) {
+        throwPackIssue("webp.header", "Invalid WebP header");
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.getUint32(4, true) + 8 !== bytes.byteLength) {
+        throwPackIssue("webp.size", "WebP size header is invalid");
+    }
+    let offset = 12;
+    let chunks = 0;
+    let alphaChunk = false;
+    let canvas;
+    let image;
+    while (offset < bytes.byteLength) {
+        if (bytes.byteLength - offset < 8) {
+            throwPackIssue("webp.chunk", "WebP chunk is truncated");
+        }
+        const type = chunkName(bytes, offset);
+        const length = view.getUint32(offset + 4, true);
+        const dataOffset = offset + 8;
+        const next = dataOffset + length + (length & 1);
+        if (next < dataOffset || next > bytes.byteLength) {
+            throwPackIssue("webp.chunk", "WebP chunk is truncated");
+        }
+        chunks += 1;
+        if (chunks > MAX_IMAGE_CHUNKS) {
+            throwPackIssue("webp.chunks", "WebP has too many chunks");
+        }
+        if (type === "ALPH") {
+            alphaChunk = true;
+        }
+        else if (type === "VP8X") {
+            if (length < 10) {
+                throwPackIssue("webp.vp8x", "WebP VP8X header is truncated");
+            }
+            canvas = webpResult(1 + uint24(bytes, dataOffset + 4), 1 + uint24(bytes, dataOffset + 7), (bytes[dataOffset] & 0x10) !== 0 || alphaChunk);
+        }
+        else if (type === "VP8L") {
+            if (length < 5 || bytes[dataOffset] !== 0x2f) {
+                throwPackIssue("webp.vp8l", "WebP VP8L header is invalid");
+            }
+            const packed = view.getUint32(dataOffset + 1, true);
+            const payload = webpResult(1 + (packed & 0x3fff), 1 + ((packed >>> 14) & 0x3fff), true);
+            image ??= canvas ?? payload;
+        }
+        else if (type === "VP8 ") {
+            if (length < 10 ||
+                bytes[dataOffset + 3] !== 0x9d ||
+                bytes[dataOffset + 4] !== 0x01 ||
+                bytes[dataOffset + 5] !== 0x2a) {
+                throwPackIssue("webp.vp8", "WebP VP8 header is invalid");
+            }
+            const payload = webpResult(view.getUint16(dataOffset + 6, true) & 0x3fff, view.getUint16(dataOffset + 8, true) & 0x3fff, alphaChunk);
+            image ??= canvas ?? payload;
+        }
+        else if (!canvas &&
+            !image &&
+            type !== "ICCP" &&
+            type !== "EXIF" &&
+            type !== "XMP ") {
+            throwPackIssue("webp.chunk-type", "WebP has an unsupported leading chunk");
+        }
+        offset = next;
+    }
+    if (image)
+        return image;
+    throwPackIssue("webp.image", "WebP image chunk is missing");
+}
+function uint24(bytes, offset) {
+    return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16));
+}
+function webpResult(width, height, hasAlpha) {
+    if (width < 1 ||
+        height < 1 ||
+        width > MAX_IMAGE_SIDE ||
+        height > MAX_IMAGE_SIDE) {
+        throwPackIssue("webp.dimensions", `WebP dimensions must be 1-${MAX_IMAGE_SIDE} per side`);
+    }
+    return { width, height, hasAlpha, mimeType: "image/webp" };
+}

package/dist/pack.d.ts

@@ -0,0 +1,6 @@
+import { type AtlasGeometry, type NormalizedPack } from "./types.js";
+export declare const MAX_ATLAS_SIDE = 4096;
+export declare function parseManifestText(text: string): unknown;
+export declare function validateNativePack(input: unknown, geometry?: AtlasGeometry, preferredDensity?: number): NormalizedPack;
+export declare function selectNativeDensity(available: readonly (1 | 2 | 4)[], required: number): 1 | 2 | 4;
+//# sourceMappingURL=pack.d.ts.map

package/dist/pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../src/pack.ts"],"names":[],"mappings":"AAiBA,OAAO,EAML,KAAK,aAAa,EAElB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAIpB,eAAO,MAAM,cAAc,OAAO,CAAC;AAyBnC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,aAAa,EACxB,gBAAgB,SAAI,GACnB,cAAc,CAqchB;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EACjC,QAAQ,EAAE,MAAM,GACf,CAAC,GAAG,CAAC,GAAG,CAAC,CAQX"}