editmamei 1.4.0 → 1.5.0

package/dist/utils/xmp-crs.js

@@ -0,0 +1,682 @@
+export const RAW_EXTENSIONS = [
+    'heic',
+    'heif',
+    'raw',
+    'cr2',
+    'cr3',
+    'nef',
+    'arw',
+    'orf',
+    'rw2',
+    'dng',
+    'raf',
+    'pef',
+    'srw',
+];
+export const SIDECAR_DEVELOPABLE_EXTENSIONS = RAW_EXTENSIONS.filter((e) => e !== 'heic' && e !== 'heif');
+const HSL_COLORS = [
+    'Red',
+    'Orange',
+    'Yellow',
+    'Green',
+    'Aqua',
+    'Blue',
+    'Purple',
+    'Magenta',
+];
+function hslFields() {
+    const out = {};
+    for (const axis of ['Hue', 'Saturation', 'Luminance']) {
+        for (const color of HSL_COLORS) {
+            out[`${axis.toLowerCase()}_${color.toLowerCase()}`] = {
+                key: `${axis}Adjustment${color}`,
+                group: 'hsl',
+                format: 'signedInt',
+                min: -100,
+                max: 100,
+            };
+        }
+    }
+    for (const color of HSL_COLORS) {
+        out[`bw_mix_${color.toLowerCase()}`] = {
+            key: `GrayMixer${color}`,
+            group: 'bw',
+            format: 'signedInt',
+            min: -100,
+            max: 100,
+        };
+    }
+    return out;
+}
+export const CRS_FIELDS = Object.freeze({
+    exposure: { key: 'Exposure2012', group: 'basic', format: 'signed2', min: -5, max: 5 },
+    contrast: { key: 'Contrast2012', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    highlights: { key: 'Highlights2012', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    shadows: { key: 'Shadows2012', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    whites: { key: 'Whites2012', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    blacks: { key: 'Blacks2012', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    texture: { key: 'Texture', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    clarity: { key: 'Clarity2012', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    dehaze: { key: 'Dehaze', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    vibrance: { key: 'Vibrance', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    saturation: { key: 'Saturation', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    temperature: {
+        key: 'Temperature',
+        group: 'basic',
+        format: 'plainInt',
+        min: 2000,
+        max: 50000,
+        note: 'Kelvin, raw files only. Requires white_balance="Custom" to take effect.',
+    },
+    tint: { key: 'Tint', group: 'basic', format: 'signedInt', min: -150, max: 150 },
+    shadow_tint: { key: 'ShadowTint', group: 'basic', format: 'signedInt', min: -100, max: 100 },
+    white_balance: {
+        key: 'WhiteBalance',
+        group: 'basic',
+        format: 'text',
+        values: [
+            'As Shot',
+            'Auto',
+            'Daylight',
+            'Cloudy',
+            'Shade',
+            'Tungsten',
+            'Fluorescent',
+            'Flash',
+            'Custom',
+        ],
+    },
+    auto_tone: {
+        key: 'AutoTone',
+        group: 'auto',
+        format: 'bool',
+        note: "Camera Raw's real Auto button. Overrides tone sliders it decides to set.",
+    },
+    upright: {
+        key: 'PerspectiveUpright',
+        group: 'geometry',
+        format: 'plainInt',
+        min: 0,
+        max: 5,
+        note: '0=Off 1=Auto 2=Level 3=Vertical 4=Full 5=Guided. Content-dependent: a frame with no detectable geometry is legitimately left unchanged.',
+    },
+    rotate: {
+        key: 'PerspectiveRotate',
+        group: 'geometry',
+        format: 'signed1',
+        min: -10,
+        max: 10,
+        verified: true,
+        note: 'MEASURED: 5.0 applies, 30.0 is silently discarded.',
+    },
+    perspective_vertical: {
+        key: 'PerspectiveVertical',
+        group: 'geometry',
+        format: 'signedInt',
+        min: -100,
+        max: 100,
+    },
+    perspective_horizontal: {
+        key: 'PerspectiveHorizontal',
+        group: 'geometry',
+        format: 'signedInt',
+        min: -100,
+        max: 100,
+    },
+    perspective_scale: {
+        key: 'PerspectiveScale',
+        group: 'geometry',
+        format: 'plainInt',
+        min: 50,
+        max: 150,
+    },
+    perspective_aspect: {
+        key: 'PerspectiveAspect',
+        group: 'geometry',
+        format: 'signedInt',
+        min: -100,
+        max: 100,
+    },
+    perspective_x: { key: 'PerspectiveX', group: 'geometry', format: 'signed2', min: -100, max: 100 },
+    perspective_y: { key: 'PerspectiveY', group: 'geometry', format: 'signed2', min: -100, max: 100 },
+    has_crop: { key: 'HasCrop', group: 'crop', format: 'bool' },
+    crop_top: { key: 'CropTop', group: 'crop', format: 'decimal6', min: 0, max: 1 },
+    crop_left: { key: 'CropLeft', group: 'crop', format: 'decimal6', min: 0, max: 1 },
+    crop_bottom: { key: 'CropBottom', group: 'crop', format: 'decimal6', min: 0, max: 1 },
+    crop_right: { key: 'CropRight', group: 'crop', format: 'decimal6', min: 0, max: 1 },
+    crop_angle: { key: 'CropAngle', group: 'crop', format: 'signed1', min: -45, max: 45 },
+    lens_profile_enable: {
+        key: 'LensProfileEnable',
+        group: 'lens',
+        format: 'plainInt',
+        min: 0,
+        max: 1,
+    },
+    manual_distortion: {
+        key: 'LensManualDistortionAmount',
+        group: 'lens',
+        format: 'signedInt',
+        min: -100,
+        max: 100,
+    },
+    defringe_purple: {
+        key: 'DefringePurpleAmount',
+        group: 'lens',
+        format: 'plainInt',
+        min: 0,
+        max: 20,
+    },
+    defringe_green: {
+        key: 'DefringeGreenAmount',
+        group: 'lens',
+        format: 'plainInt',
+        min: 0,
+        max: 20,
+    },
+    sharpness: { key: 'Sharpness', group: 'detail', format: 'plainInt', min: 0, max: 150 },
+    sharpen_radius: { key: 'SharpenRadius', group: 'detail', format: 'signed1', min: 0.5, max: 3 },
+    sharpen_detail: { key: 'SharpenDetail', group: 'detail', format: 'plainInt', min: 0, max: 100 },
+    sharpen_masking: {
+        key: 'SharpenEdgeMasking',
+        group: 'detail',
+        format: 'plainInt',
+        min: 0,
+        max: 100,
+    },
+    luminance_noise_reduction: {
+        key: 'LuminanceSmoothing',
+        group: 'detail',
+        format: 'plainInt',
+        min: 0,
+        max: 100,
+    },
+    color_noise_reduction: {
+        key: 'ColorNoiseReduction',
+        group: 'detail',
+        format: 'plainInt',
+        min: 0,
+        max: 100,
+    },
+    split_shadow_hue: {
+        key: 'SplitToningShadowHue',
+        group: 'split_tone',
+        format: 'plainInt',
+        min: 0,
+        max: 360,
+    },
+    split_shadow_saturation: {
+        key: 'SplitToningShadowSaturation',
+        group: 'split_tone',
+        format: 'plainInt',
+        min: 0,
+        max: 100,
+    },
+    split_highlight_hue: {
+        key: 'SplitToningHighlightHue',
+        group: 'split_tone',
+        format: 'plainInt',
+        min: 0,
+        max: 360,
+    },
+    split_highlight_saturation: {
+        key: 'SplitToningHighlightSaturation',
+        group: 'split_tone',
+        format: 'plainInt',
+        min: 0,
+        max: 100,
+    },
+    split_balance: {
+        key: 'SplitToningBalance',
+        group: 'split_tone',
+        format: 'signedInt',
+        min: -100,
+        max: 100,
+    },
+    post_crop_vignette: {
+        key: 'PostCropVignetteAmount',
+        group: 'effects',
+        format: 'signedInt',
+        min: -100,
+        max: 100,
+    },
+    grain_amount: { key: 'GrainAmount', group: 'effects', format: 'plainInt', min: 0, max: 100 },
+    grain_size: { key: 'GrainSize', group: 'effects', format: 'plainInt', min: 0, max: 100 },
+    convert_to_grayscale: { key: 'ConvertToGrayscale', group: 'bw', format: 'bool' },
+    camera_profile: {
+        key: 'CameraProfile',
+        group: 'profile',
+        format: 'text',
+        note: 'Resolves BY NAME (e.g. "Camera Landscape", "Adobe Standard"). Creative Looks do NOT resolve by name and are not exposed.',
+    },
+    ...hslFields(),
+});
+export const CRS_CURVES = Object.freeze({
+    curve: 'ToneCurvePV2012',
+    curve_red: 'ToneCurvePV2012Red',
+    curve_green: 'ToneCurvePV2012Green',
+    curve_blue: 'ToneCurvePV2012Blue',
+});
+export function isCrsField(name) {
+    return Object.prototype.hasOwnProperty.call(CRS_FIELDS, name);
+}
+export function isCrsCurve(name) {
+    return Object.prototype.hasOwnProperty.call(CRS_CURVES, name);
+}
+export function validateCrsChanges(changes) {
+    const errors = [];
+    for (const [name, raw] of Object.entries(changes.fields ?? {})) {
+        if (!isCrsField(name)) {
+            errors.push(`Unknown develop field '${name}'.`);
+            continue;
+        }
+        const spec = CRS_FIELDS[name];
+        if (spec.format === 'bool') {
+            if (typeof raw !== 'boolean')
+                errors.push(`'${name}' must be true or false, got ${JSON.stringify(raw)}.`);
+            continue;
+        }
+        if (spec.format === 'text') {
+            if (typeof raw !== 'string' || raw.length === 0) {
+                errors.push(`'${name}' must be a non-empty string, got ${JSON.stringify(raw)}.`);
+            }
+            else if (spec.values && !spec.values.includes(raw)) {
+                errors.push(`'${name}' must be one of ${spec.values.join(', ')}; got '${raw}'.`);
+            }
+            continue;
+        }
+        if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+            errors.push(`'${name}' must be a number, got ${JSON.stringify(raw)}.`);
+            continue;
+        }
+        if (spec.min !== undefined && raw < spec.min) {
+            errors.push(rangeError(name, spec, raw));
+        }
+        else if (spec.max !== undefined && raw > spec.max) {
+            errors.push(rangeError(name, spec, raw));
+        }
+    }
+    for (const [name, points] of Object.entries(changes.curves ?? {})) {
+        if (!isCrsCurve(name)) {
+            errors.push(`Unknown curve '${name}'. Valid: ${Object.keys(CRS_CURVES).join(', ')}.`);
+            continue;
+        }
+        if (!Array.isArray(points) || points.length < 2) {
+            errors.push(`'${name}' needs at least 2 [input, output] points.`);
+            continue;
+        }
+        for (const p of points) {
+            if (!Array.isArray(p) ||
+                p.length !== 2 ||
+                p.some((n) => !Number.isFinite(n) || n < 0 || n > 255)) {
+                errors.push(`'${name}' points must be [input, output] pairs in 0-255; got ${JSON.stringify(p)}.`);
+                break;
+            }
+        }
+    }
+    return errors;
+}
+export function applyCrsCoherence(changes, callerFields) {
+    const fields = { ...(changes.fields ?? {}) };
+    const notes = [];
+    const cropEdges = ['crop_top', 'crop_left', 'crop_bottom', 'crop_right', 'crop_angle'];
+    const anyCropEdge = cropEdges.some((k) => k in fields);
+    const callerTypedCropEdge = cropEdges.some((k) => callerFields.has(k));
+    if (anyCropEdge) {
+        if (fields.has_crop === undefined) {
+            fields.has_crop = true;
+            notes.push('Set has_crop=true: Camera Raw ignores a crop box without it.');
+        }
+        else if (fields.has_crop === false) {
+            if (callerTypedCropEdge && callerFields.has('has_crop')) {
+                throw new Error('Crop edges only take effect with has_crop=true, but has_crop=false was given. ' +
+                    'Pass has_crop=true, or drop the crop edge values.');
+            }
+            if (callerTypedCropEdge) {
+                fields.has_crop = true;
+                notes.push('Set has_crop=true: the file had has_crop=false, which would have made the crop values you passed do nothing.');
+            }
+        }
+    }
+    const wbDriven = 'temperature' in fields || 'tint' in fields;
+    const callerTypedWbValue = callerFields.has('temperature') || callerFields.has('tint');
+    if (wbDriven) {
+        const wb = fields.white_balance;
+        if (wb === undefined) {
+            fields.white_balance = 'Custom';
+            notes.push('Set white_balance="Custom": Camera Raw ignores temperature/tint under any other white-balance mode.');
+        }
+        else if (wb !== 'Custom') {
+            if (callerTypedWbValue && callerFields.has('white_balance')) {
+                throw new Error(`temperature/tint only take effect with white_balance="Custom", but white_balance="${String(wb)}" was given. ` +
+                    `Pass white_balance="Custom", or drop the temperature/tint values.`);
+            }
+            if (callerTypedWbValue) {
+                fields.white_balance = 'Custom';
+                notes.push(`Set white_balance="Custom": the file had white_balance="${String(wb)}", under which the temperature/tint you passed would be ignored.`);
+            }
+        }
+    }
+    return { changes: { ...changes, fields }, notes };
+}
+function rangeError(name, spec, got) {
+    const measured = spec.verified
+        ? ' (boundary measured against live Camera Raw — out-of-range values are discarded silently)'
+        : '';
+    return `'${name}' must be between ${spec.min} and ${spec.max}; got ${got}${measured}.`;
+}
+export function formatCrsValue(spec, value) {
+    switch (spec.format) {
+        case 'bool':
+            return value ? 'True' : 'False';
+        case 'text':
+            return escapeXmlAttr(String(value));
+        case 'plainInt':
+            return String(Math.round(Number(value)));
+        case 'decimal6':
+            return Number(value).toFixed(6);
+        case 'signed2':
+            return signed(Number(value).toFixed(2), Number(value));
+        case 'signed1':
+            return signed(Number(value).toFixed(1), Number(value));
+        case 'signedInt':
+            return signed(String(Math.round(Number(value))), Number(value));
+        default:
+            return String(value);
+    }
+}
+function signed(rendered, value) {
+    return value > 0 ? `+${rendered}` : rendered;
+}
+function unescapeXmlAttr(s) {
+    return s
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&');
+}
+function escapeXmlAttr(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function scanDescriptionAt(xmp, open) {
+    const attrsStart = open + '<rdf:Description'.length;
+    let i = attrsStart;
+    let quote = null;
+    while (i < xmp.length) {
+        const c = xmp[i];
+        if (quote) {
+            if (c === quote)
+                quote = null;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '>') {
+            const selfClosing = xmp[i - 1] === '/';
+            return {
+                attrsStart,
+                attrsEnd: selfClosing ? i - 1 : i,
+                selfClosing,
+                tagEnd: i + 1,
+            };
+        }
+        i++;
+    }
+    return null;
+}
+export function findTopLevelDescription(xmp) {
+    let first = null;
+    const re = /<(\/?)(crs:[A-Za-z0-9_]+|rdf:Description)([^>]*?)(\/?)>/g;
+    let crsDepth = 0;
+    let m;
+    while ((m = re.exec(xmp)) !== null) {
+        const [, closing, qname, , selfClosing] = m;
+        if (qname.startsWith('crs:')) {
+            if (closing === '/')
+                crsDepth--;
+            else if (selfClosing !== '/')
+                crsDepth++;
+            continue;
+        }
+        if (closing === '/')
+            continue;
+        if (crsDepth > 0)
+            continue;
+        const tag = scanDescriptionAt(xmp, m.index);
+        if (!tag)
+            break;
+        if (!first)
+            first = tag;
+        const attrs = xmp.slice(tag.attrsStart, tag.attrsEnd);
+        if (/\scrs:[A-Za-z0-9_]+=/.test(attrs) || /xmlns:crs=/.test(attrs))
+            return tag;
+        re.lastIndex = Math.max(re.lastIndex, tag.tagEnd);
+    }
+    return first;
+}
+function emptySidecar() {
+    return ('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 7.0">\n' +
+        ' <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">\n' +
+        '  <rdf:Description rdf:about=""\n' +
+        '    xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/"\n' +
+        '   crs:Version="18.2.2"\n' +
+        '   crs:ProcessVersion="15.4"\n' +
+        '   crs:HasSettings="True"/>\n' +
+        ' </rdf:RDF>\n' +
+        '</x:xmpmeta>\n');
+}
+function renderCurve(key, points) {
+    const items = points
+        .map(([i, o]) => `    <rdf:li>${Math.round(i)}, ${Math.round(o)}</rdf:li>`)
+        .join('\n');
+    return `   <crs:${key}>\n    <rdf:Seq>\n${items}\n    </rdf:Seq>\n   </crs:${key}>`;
+}
+function indentBlock(block) {
+    const lines = block.trim().split('\n');
+    const lead = /^\s*/.exec(lines[0])?.[0].length ?? 0;
+    return lines
+        .map((l) => '   ' + l.slice(Math.min(lead, /^\s*/.exec(l)?.[0].length ?? 0)))
+        .join('\n');
+}
+const XML_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
+function topLevelChildBlocks(xmp) {
+    const tag = findTopLevelDescription(xmp);
+    if (!tag || tag.selfClosing)
+        return [];
+    const spans = [];
+    const re = /<(\/?)(crs:[A-Za-z0-9_]+|rdf:Description)([^>]*?)(\/?)>/g;
+    re.lastIndex = tag.tagEnd;
+    let depth = 0;
+    let openStart = -1;
+    let openTag = '';
+    let m;
+    while ((m = re.exec(xmp)) !== null) {
+        const [full, closing, qname, , selfClosing] = m;
+        const isCrs = qname.startsWith('crs:');
+        const name = isCrs ? qname.slice(4) : qname;
+        if (closing === '/') {
+            if (depth === 0)
+                break;
+            depth--;
+            if (depth === 0 && isCrs && name === openTag) {
+                spans.push({ tag: openTag, start: openStart, end: m.index + full.length });
+                openStart = -1;
+                openTag = '';
+            }
+        }
+        else if (selfClosing === '/') {
+            if (depth === 0 && isCrs) {
+                spans.push({ tag: name, start: m.index, end: m.index + full.length });
+            }
+        }
+        else {
+            if (depth === 0 && isCrs) {
+                openStart = m.index;
+                openTag = name;
+            }
+            depth++;
+        }
+    }
+    return spans;
+}
+export function extractChildBlock(xmp, tagName) {
+    if (!XML_NAME.test(tagName)) {
+        throw new Error(`Refusing to read a block with a non-identifier tag name: '${tagName}'.`);
+    }
+    const span = topLevelChildBlocks(xmp).find((s) => s.tag === tagName);
+    return span ? xmp.slice(span.start, span.end) : null;
+}
+function upsertChildBlock(xmp, tagName, blockText) {
+    if (!XML_NAME.test(tagName)) {
+        throw new Error(`Refusing to write a block with a non-identifier tag name: '${tagName}'.`);
+    }
+    const existing = topLevelChildBlocks(xmp).find((s) => s.tag === tagName);
+    if (existing) {
+        return (xmp.slice(0, existing.start) + blockText.replace(/^[ \t]+/, '') + xmp.slice(existing.end));
+    }
+    const tag = findTopLevelDescription(xmp);
+    if (!tag)
+        throw new Error('Sidecar structure changed unexpectedly during merge.');
+    if (tag.selfClosing) {
+        return (xmp.slice(0, tag.attrsEnd) +
+            '>\n' +
+            blockText +
+            '\n  </rdf:Description>' +
+            xmp.slice(tag.tagEnd));
+    }
+    return xmp.slice(0, tag.tagEnd) + '\n' + blockText + xmp.slice(tag.tagEnd);
+}
+const CARRYABLE_BLOCKS = [
+    'Look',
+    'ToneCurvePV2012',
+    'ToneCurvePV2012Red',
+    'ToneCurvePV2012Green',
+    'ToneCurvePV2012Blue',
+];
+const UNCARRYABLE_BLOCKS = [
+    [
+        'MaskGroupBasedCorrections',
+        'local/AI-mask adjustments — hand-moved mask blocks are discarded by Camera Raw, so carrying them would promise an edit that silently would not happen',
+    ],
+    ['PointColors', 'point-colour adjustments — untested through a written sidecar'],
+    ['RetouchAreas', 'healing/spot removal — untested through a written sidecar'],
+];
+export function readPresetChanges(presetXmp) {
+    const raw = readTopLevelCrs(presetXmp);
+    const byKey = new Map(Object.entries(CRS_FIELDS).map(([name, spec]) => [spec.key, name]));
+    const fields = {};
+    const applied = [];
+    const rangeSkips = [];
+    for (const [key, value] of Object.entries(raw)) {
+        const name = byKey.get(key);
+        if (!name)
+            continue;
+        const spec = CRS_FIELDS[name];
+        let candidate;
+        if (spec.format === 'bool')
+            candidate = value === 'True';
+        else if (spec.format === 'text')
+            candidate = value;
+        else {
+            const n = Number(value);
+            if (!Number.isFinite(n))
+                continue;
+            candidate = n;
+        }
+        const problems = validateCrsChanges({ fields: { [name]: candidate } });
+        if (problems.length > 0) {
+            rangeSkips.push(`${name}: ${problems[0]}`);
+            continue;
+        }
+        fields[name] = candidate;
+        applied.push(name);
+    }
+    const blocks = {};
+    const carried = [];
+    for (const tagName of CARRYABLE_BLOCKS) {
+        const block = extractChildBlock(presetXmp, tagName);
+        if (block) {
+            blocks[tagName] = block;
+            carried.push(tagName);
+        }
+    }
+    const skipped = [...rangeSkips];
+    for (const [tagName, why] of UNCARRYABLE_BLOCKS) {
+        if (extractChildBlock(presetXmp, tagName))
+            skipped.push(`${tagName}: ${why}`);
+    }
+    return { changes: { fields, blocks }, applied: applied.sort(), carried: carried.sort(), skipped };
+}
+export function mergeCrsIntoSidecar(original, changes) {
+    const errors = validateCrsChanges(changes);
+    if (errors.length > 0) {
+        throw new Error(`Invalid develop settings:\n- ${errors.join('\n- ')}`);
+    }
+    let xmp = original && original.includes('<rdf:Description') ? original : emptySidecar();
+    const tag = findTopLevelDescription(xmp);
+    if (!tag) {
+        throw new Error('Sidecar has no <rdf:Description> element; refusing to guess its structure.');
+    }
+    const attrs = [['HasSettings', 'True']];
+    for (const [name, value] of Object.entries(changes.fields ?? {})) {
+        const spec = CRS_FIELDS[name];
+        attrs.push([spec.key, formatCrsValue(spec, value)]);
+    }
+    let region = xmp.slice(tag.attrsStart, tag.attrsEnd);
+    for (const [key, rendered] of attrs) {
+        const existing = new RegExp(`(\\scrs:${key}=")[^"]*(")`);
+        if (existing.test(region)) {
+            region = region.replace(existing, (_m, open, close) => open + rendered + close);
+        }
+        else {
+            region = `${region}\n   crs:${key}="${rendered}"`;
+        }
+    }
+    if (!/xmlns:crs=/.test(region) && !/xmlns:crs=/.test(xmp.slice(0, tag.attrsStart))) {
+        region = `\n    xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/"${region}`;
+    }
+    xmp = xmp.slice(0, tag.attrsStart) + region + xmp.slice(tag.attrsEnd);
+    for (const [tagName, blockText] of Object.entries(changes.blocks ?? {})) {
+        xmp = upsertChildBlock(xmp, tagName, indentBlock(blockText));
+    }
+    for (const [name, points] of Object.entries(changes.curves ?? {})) {
+        xmp = upsertChildBlock(xmp, CRS_CURVES[name], renderCurve(CRS_CURVES[name], points));
+    }
+    return xmp;
+}
+export function readTopLevelCrs(xmp) {
+    const tag = findTopLevelDescription(xmp);
+    if (!tag)
+        return {};
+    const region = xmp.slice(tag.attrsStart, tag.attrsEnd);
+    const out = {};
+    const re = /crs:([A-Za-z0-9_]+)="([^"]*)"/g;
+    let m;
+    while ((m = re.exec(region)))
+        out[m[1]] = unescapeXmlAttr(m[2]);
+    return out;
+}
+export function describeSidecar(xmp) {
+    const raw = readTopLevelCrs(xmp);
+    const byKey = new Map(Object.entries(CRS_FIELDS).map(([name, spec]) => [spec.key, name]));
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const name = byKey.get(key);
+        if (!name)
+            continue;
+        const spec = CRS_FIELDS[name];
+        if (spec.format === 'bool')
+            out[name] = value === 'True';
+        else if (spec.format === 'text')
+            out[name] = value;
+        else {
+            const n = Number(value);
+            out[name] = Number.isFinite(n) ? n : value;
+        }
+    }
+    return out;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.4.0';
+export const VERSION = '1.5.0';