exiftool-vendored 36.0.0 → 37.0.0

package/dist/TagEdit.spec.js

@@ -0,0 +1,863 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const _chai_spec_1 = require("./_chai.spec");
+const ExifTool_1 = require("./ExifTool");
+const TagEdit_1 = require("./TagEdit");
+const WriteTask_1 = require("./WriteTask");
+function regionList(tags) {
+    return tags.RegionInfo.RegionList;
+}
+async function readQualifiedTag(exiftool, file, tag) {
+    const raw = (await exiftool.readRaw(file, {
+        readArgs: ["-G1", "-struct", `-${tag}`],
+    }));
+    return raw[tag];
+}
+describe("ExifTool.editTags()", () => {
+    const exiftool = new ExifTool_1.ExifTool();
+    after(() => (0, _chai_spec_1.end)(exiftool));
+    async function seedCollections(file) {
+        await exiftool.write(file, {
+            Collections: [
+                {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:vacation",
+                },
+                {
+                    CollectionName: "Portfolio",
+                    CollectionURI: "urn:portfolio",
+                },
+            ],
+            Subject: ["before"],
+        });
+    }
+    async function expectNoModification(file, edits, message) {
+        const before = await (0, _chai_spec_1.sha1)(file);
+        await (0, _chai_spec_1.expect)(exiftool.editTags(file, edits)).to.be.rejectedWith(message);
+        (0, _chai_spec_1.expect)(await (0, _chai_spec_1.sha1)(file)).to.eql(before);
+    }
+    it("preserves operation order in generated ExifTool arguments", () => {
+        const edits = [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "beach",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+        ];
+        const task = WriteTask_1.WriteTask.forTagEdits("image.jpg", edits, ExifTool_1.DefaultWriteTaskOptions);
+        (0, _chai_spec_1.expect)(task.args.filter((arg) => arg.startsWith("-XMP-dc:Subject"))).to.eql([
+            "-XMP-dc:Subject-=beach",
+            "-XMP-dc:Subject+=forest",
+            "-XMP-dc:Subject+=forest",
+        ]);
+    });
+    it("accepts every audited add-capable string-list tag", () => {
+        const edits = TagEdit_1.TagEditAddTagNames.values.map((tag) => ({
+            tag,
+            operation: "add",
+            value: "value",
+        }));
+        const task = WriteTask_1.WriteTask.forTagEdits("image.jpg", edits, ExifTool_1.DefaultWriteTaskOptions);
+        for (const tag of TagEdit_1.TagEditAddTagNames) {
+            (0, _chai_spec_1.expect)(task.args).to.include(`-${tag}+=value`);
+        }
+        (0, _chai_spec_1.expect)(TagEdit_1.TagEditTagNames.includes("XMP-mwg-coll:Collections")).to.eql(true);
+    });
+    it("accepts every audited remove-capable primitive tag", () => {
+        const edits = TagEdit_1.TagEditValueTagNames.values.map((tag) => ({
+            tag,
+            operation: "remove",
+            value: "value",
+        }));
+        const task = WriteTask_1.WriteTask.forTagEdits("image.jpg", edits, ExifTool_1.DefaultWriteTaskOptions);
+        for (const tag of TagEdit_1.TagEditValueTagNames) {
+            (0, _chai_spec_1.expect)(task.args).to.include(`-${tag}-=value`);
+        }
+    });
+    it("removes every exact match and preserves duplicate additions", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        await exiftool.write(file, {
+            Subject: ["remove", "keep", "remove"],
+        });
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "remove",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+        ]);
+        const raw = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-dc:Subject"],
+        }));
+        const subject = raw["XMP-dc:Subject"];
+        (0, _chai_spec_1.expect)(subject).to.be.an("array");
+        (0, _chai_spec_1.expect)([...subject].sort()).to.eql(["forest", "forest", "keep"].sort());
+    });
+    it("targets only the qualified metadata group", async () => {
+        const file = await (0, _chai_spec_1.testImg)();
+        const before = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-dc:Subject", "-IPTC:Keywords"],
+        }));
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "beach",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+        ]);
+        const after = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-dc:Subject", "-IPTC:Keywords"],
+        }));
+        (0, _chai_spec_1.expect)(after["XMP-dc:Subject"]).to.include("forest");
+        (0, _chai_spec_1.expect)(after["XMP-dc:Subject"]).to.not.include("beach");
+        (0, _chai_spec_1.expect)(after["IPTC:Keywords"]).to.eql(before["IPTC:Keywords"]);
+    });
+    it("edits exact hierarchical keyword values", async () => {
+        const file = await (0, _chai_spec_1.testFile)("hierarchical-keywords.xmp");
+        await exiftool.write(file, {
+            "XMP-lr:HierarchicalSubject": ["Places|Beach", "Places|Forest"],
+        });
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-lr:HierarchicalSubject",
+                operation: "remove",
+                value: "Places|Beach",
+            },
+            {
+                tag: "XMP-lr:HierarchicalSubject",
+                operation: "add",
+                value: "Places|Mountain",
+            },
+        ]);
+        const raw = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-lr:HierarchicalSubject"],
+        }));
+        (0, _chai_spec_1.expect)([...raw["XMP-lr:HierarchicalSubject"]].sort()).to.eql(["Places|Forest", "Places|Mountain"].sort());
+    });
+    it("removes a Collection matching a strict non-empty predicate", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await seedCollections(file);
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "remove",
+                predicate: { CollectionName: "Vacation" },
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "Portfolio",
+                CollectionURI: "urn:portfolio",
+            },
+        ]);
+    });
+    it("encodes only the validated snapshot of a Collection predicate", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await exiftool.write(file, {
+            Collections: [
+                {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:vacation",
+                },
+                {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:other-vacation",
+                },
+            ],
+        });
+        let predicateReads = 0;
+        const edit = {
+            tag: "XMP-mwg-coll:Collections",
+            operation: "remove",
+            get predicate() {
+                predicateReads++;
+                return predicateReads === 1
+                    ? {
+                        CollectionName: "Vacation",
+                        CollectionURI: "urn:vacation",
+                    }
+                    : { CollectionName: "Vacation", Typo: "x" };
+            },
+        };
+        await exiftool.editTags(file, [edit]);
+        (0, _chai_spec_1.expect)(predicateReads).to.eql(1);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "Vacation",
+                CollectionURI: "urn:other-vacation",
+            },
+        ]);
+    });
+    it("includes non-enumerable own fields in a Collection predicate", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await exiftool.write(file, {
+            Collections: [
+                {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:vacation",
+                },
+                {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:other-vacation",
+                },
+            ],
+        });
+        const predicate = { CollectionName: "Vacation" };
+        Object.defineProperty(predicate, "CollectionURI", {
+            value: "urn:vacation",
+        });
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "remove",
+                predicate,
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "Vacation",
+                CollectionURI: "urn:other-vacation",
+            },
+        ]);
+    });
+    it("rejects accessor fields in Collection values without modifying metadata", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await seedCollections(file);
+        const value = { CollectionURI: "urn:new" };
+        Object.defineProperty(value, "CollectionName", {
+            enumerable: true,
+            get() {
+                return "Dynamic";
+            },
+        });
+        await expectNoModification(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value,
+            },
+        ], /data properties/i);
+    });
+    it("matches leading whitespace in Collection predicates exactly", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value: {
+                    CollectionName: " Vacation",
+                    CollectionURI: "urn:leading",
+                },
+            },
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value: {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:plain",
+                },
+            },
+        ]);
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "remove",
+                predicate: { CollectionName: " Vacation" },
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "Vacation",
+                CollectionURI: "urn:plain",
+            },
+        ]);
+    });
+    it("round-trips structural delimiters inside Collection fields", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value: {
+                    CollectionName: "{Vacation}",
+                    CollectionURI: "urn:[vacation]",
+                },
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "{Vacation}",
+                CollectionURI: "urn:[vacation]",
+            },
+        ]);
+    });
+    it("distinguishes HTML entities from decoded text in Collection fields", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value: {
+                    CollectionName: "A & B",
+                    CollectionURI: "urn:entity",
+                },
+            },
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value: {
+                    CollectionName: "A & B",
+                    CollectionURI: "urn:ampersand",
+                },
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "A & B",
+                CollectionURI: "urn:entity",
+            },
+            {
+                CollectionName: "A & B",
+                CollectionURI: "urn:ampersand",
+            },
+        ]);
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "remove",
+                predicate: { CollectionName: "A & B" },
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "A & B",
+                CollectionURI: "urn:ampersand",
+            },
+        ]);
+    });
+    it("adds one validated Collection structure", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "add",
+                value: {
+                    CollectionName: "Vacation",
+                    CollectionURI: "urn:vacation",
+                },
+            },
+        ]);
+        (0, _chai_spec_1.expect)((await exiftool.read(file)).Collections).to.eql([
+            {
+                CollectionName: "Vacation",
+                CollectionURI: "urn:vacation",
+            },
+        ]);
+    });
+    it("removes a flattened face name without deleting its geometry", async () => {
+        const file = await (0, _chai_spec_1.testImg)({ srcBasename: "with_faces.jpg" });
+        const before = regionList(await exiftool.read(file));
+        const bobBefore = before.find((region) => region.Name === "Bob Jones");
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-mwg-rs:RegionName",
+                operation: "remove",
+                value: "Bob Jones",
+            },
+        ]);
+        const after = regionList(await exiftool.read(file));
+        (0, _chai_spec_1.expect)(after).to.have.length(before.length);
+        (0, _chai_spec_1.expect)(after.find((region) => region.Name === "Alice Smith")).to.eql(before.find((region) => region.Name === "Alice Smith"));
+        const unnamedBob = after.find((region) => region.Type === "Face" && region.Name == null);
+        (0, _chai_spec_1.expect)(unnamedBob?.Area).to.eql(bobBefore.Area);
+    });
+    it("removes an exact XMP album scalar", async () => {
+        const file = await (0, _chai_spec_1.testFile)("album.xmp");
+        await exiftool.write(file, { "XMP-xmpDM:Album": "Vacation" });
+        await exiftool.editTags(file, [
+            { tag: "XMP-xmpDM:Album", operation: "remove", value: "Other" },
+        ]);
+        (0, _chai_spec_1.expect)(await readQualifiedTag(exiftool, file, "XMP-xmpDM:Album")).to.eql("Vacation");
+        await exiftool.editTags(file, [
+            { tag: "XMP-xmpDM:Album", operation: "remove", value: "Vacation" },
+        ]);
+        (0, _chai_spec_1.expect)(await readQualifiedTag(exiftool, file, "XMP-xmpDM:Album")).to.eql(undefined);
+    });
+    it("removes audited flattened region names without deleting sibling fields", async () => {
+        const file = await (0, _chai_spec_1.testFile)("person-structures.xmp");
+        await exiftool.write(file, {
+            "XMP-acdsee-rs:RegionInfoACDSee": {
+                AppliedToDimensions: { H: 800, Unit: "pixel", W: 1200 },
+                RegionList: [
+                    {
+                        ALGArea: { H: 0.2, W: 0.2, X: 0.3, Y: 0.4 },
+                        Name: "Jane",
+                        NameAssignType: "manual",
+                        Type: "Face",
+                    },
+                    {
+                        DLYArea: { H: 0.4, W: 0.3, X: 0.2, Y: 0.1 },
+                        Name: "Keep",
+                        NameAssignType: "manual",
+                        Type: "Object",
+                    },
+                ],
+            },
+            "XMP-MP:RegionInfoMP": {
+                Regions: [
+                    {
+                        PersonDisplayName: "Jane",
+                        PersonSourceID: "id-jane",
+                        Rectangle: "0.1, 0.2, 0.3, 0.4",
+                    },
+                    {
+                        PersonDisplayName: "Keep",
+                        PersonSourceID: "id-keep",
+                        Rectangle: "0.5, 0.6, 0.2, 0.2",
+                    },
+                ],
+            },
+        });
+        const beforeNonmatch = await (0, _chai_spec_1.sha1)(file);
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-acdsee-rs:ACDSeeRegionName",
+                operation: "remove",
+                value: "Other",
+            },
+            {
+                tag: "XMP-MP:RegionPersonDisplayName",
+                operation: "remove",
+                value: "Other",
+            },
+        ]);
+        (0, _chai_spec_1.expect)(await (0, _chai_spec_1.sha1)(file)).to.eql(beforeNonmatch);
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-acdsee-rs:ACDSeeRegionName",
+                operation: "remove",
+                value: "Jane",
+            },
+            {
+                tag: "XMP-MP:RegionPersonDisplayName",
+                operation: "remove",
+                value: "Jane",
+            },
+        ]);
+        (0, _chai_spec_1.expect)(await readQualifiedTag(exiftool, file, "XMP-acdsee-rs:RegionInfoACDSee")).to.eql({
+            AppliedToDimensions: { H: 800, Unit: "pixel", W: 1200 },
+            RegionList: [
+                {
+                    ALGArea: { H: 0.2, W: 0.2, X: 0.3, Y: 0.4 },
+                    NameAssignType: "manual",
+                    Type: "Face",
+                },
+                {
+                    DLYArea: { H: 0.4, W: 0.3, X: 0.2, Y: 0.1 },
+                    Name: "Keep",
+                    NameAssignType: "manual",
+                    Type: "Object",
+                },
+            ],
+        });
+        (0, _chai_spec_1.expect)(await readQualifiedTag(exiftool, file, "XMP-MP:RegionInfoMP")).to.eql({
+            Regions: [
+                {
+                    PersonSourceID: "id-jane",
+                    Rectangle: "0.1, 0.2, 0.3, 0.4",
+                },
+                {
+                    PersonDisplayName: "Keep",
+                    PersonSourceID: "id-keep",
+                    Rectangle: "0.5, 0.6, 0.2, 0.2",
+                },
+            ],
+        });
+    });
+    it("prunes flattened region structures left empty after removal", async () => {
+        const file = await (0, _chai_spec_1.testFile)("empty-person-structures.xmp");
+        await exiftool.write(file, {
+            "XMP-acdsee-rs:RegionInfoACDSee": {
+                RegionList: [{ Name: "Jane" }],
+            },
+            "XMP-MP:RegionInfoMP": {
+                Regions: [{ PersonDisplayName: "Jane" }],
+            },
+        });
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-acdsee-rs:ACDSeeRegionName",
+                operation: "remove",
+                value: "Jane",
+            },
+            {
+                tag: "XMP-MP:RegionPersonDisplayName",
+                operation: "remove",
+                value: "Jane",
+            },
+        ]);
+        (0, _chai_spec_1.expect)(await readQualifiedTag(exiftool, file, "XMP-acdsee-rs:RegionInfoACDSee")).to.eql(undefined);
+        (0, _chai_spec_1.expect)(await readQualifiedTag(exiftool, file, "XMP-MP:RegionInfoMP")).to.eql(undefined);
+    });
+    it("rejects adding a flattened RegionName without modifying metadata", async () => {
+        const file = await (0, _chai_spec_1.testImg)({ srcBasename: "with_faces.jpg" });
+        await expectNoModification(file, [
+            {
+                tag: "XMP-mwg-rs:RegionName",
+                operation: "add",
+                value: "Ghost",
+            },
+        ], /RegionName.*remove-only/i);
+    });
+    it("rejects adding every remove-only primitive tag", async () => {
+        const file = await (0, _chai_spec_1.testImg)({ srcBasename: "with_faces.jpg" });
+        for (const tag of TagEdit_1.TagEditRemoveOnlyTagNames) {
+            await expectNoModification(file, [{ tag, operation: "add", value: "Ghost" }], new RegExp(`${tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}.*remove-only`, "i"));
+        }
+    });
+    it("rejects an empty edit list before invoking ExifTool", async () => {
+        await (0, _chai_spec_1.expect)(exiftool.editTags(await (0, _chai_spec_1.testFile)("missing.jpg"), [])).to.be.rejectedWith(/at least one tag edit/i);
+    });
+    for (const edit of [
+        { tag: "Subject", operation: "remove", value: "beach" },
+        { tag: "XMP-dc:Subject", operation: "remove", value: null },
+        { tag: "XMP-dc:Subject", operation: "add", value: undefined },
+        { tag: "XMP-dc:Subject", operation: "add", value: ["a", "b"] },
+        { tag: "XMP-dc:Subject", operation: "add", value: 42 },
+        { tag: "XMP-dc:Subject", operation: "add", value: true },
+        { tag: "XMP-dc:Subject", operation: "add", value: "" },
+        { tag: "XMP-dc:Subject", operation: "set", value: "forest" },
+    ]) {
+        it(`rejects invalid edit ${JSON.stringify(edit)}`, async () => {
+            await (0, _chai_spec_1.expect)(exiftool.editTags(await (0, _chai_spec_1.testFile)("missing.jpg"), [edit])).to.be.rejectedWith(/edit|group-qualified|operation|value|string|supported/i);
+        });
+    }
+    for (const tag of [
+        "XMP-xmp:CreateDate",
+        "XMP-iptcExt:PersonInImageName",
+        "XMP:All",
+        "XMP:Subject",
+        "XMP-custom:People",
+    ]) {
+        it(`rejects unsupported or alias tag ${tag} before writing`, async () => {
+            const file = await (0, _chai_spec_1.testImg)();
+            await expectNoModification(file, [
+                {
+                    tag,
+                    operation: "remove",
+                    value: tag === "XMP-xmp:CreateDate" ? "0:0:0 0:0:1" : "Prior Title",
+                },
+            ], /not supported|canonical/i);
+        });
+    }
+    it("rejects an empty Collection predicate without modifying metadata", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await seedCollections(file);
+        await expectNoModification(file, [
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "remove",
+                predicate: {},
+            },
+        ], /non-empty predicate/i);
+    });
+    for (const { predicate, message } of [
+        {
+            predicate: { CollectionName: "Vacation", Typo: "x" },
+            message: /unknown Collection predicate field.*Typo/i,
+        },
+        {
+            predicate: { CollectionName: { Value: "Vacation" } },
+            message: /CollectionName.*string/i,
+        },
+        {
+            predicate: { CollectionURI: 42 },
+            message: /CollectionURI.*string/i,
+        },
+    ]) {
+        it(`rejects invalid Collection predicate ${JSON.stringify(predicate)} without modifying metadata`, async () => {
+            const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+            await seedCollections(file);
+            await expectNoModification(file, [
+                {
+                    tag: "XMP-mwg-coll:Collections",
+                    operation: "remove",
+                    predicate,
+                },
+            ], message);
+        });
+    }
+    it("validates every predicate before writing any edit", async () => {
+        const file = await (0, _chai_spec_1.testFile)("collections.xmp");
+        await seedCollections(file);
+        await expectNoModification(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "should-not-be-written",
+            },
+            {
+                tag: "XMP-mwg-coll:Collections",
+                operation: "remove",
+                predicate: { CollectionName: "Vacation", Typo: "x" },
+            },
+        ], /unknown Collection predicate field.*Typo/i);
+    });
+    it("rejects predicates for unsupported structured tags", async () => {
+        const file = await (0, _chai_spec_1.testImg)({ srcBasename: "with_faces.jpg" });
+        await expectNoModification(file, [
+            {
+                tag: "XMP-mwg-rs:RegionList",
+                operation: "remove",
+                predicate: { Name: "Bob Jones", Type: "Face" },
+            },
+        ], /not supported/i);
+    });
+    for (const value of [
+        "{Name=Bob Jones,Type=Face}",
+        " {Name=Bob Jones,Type=Face}",
+    ]) {
+        it(`rejects unsupported structured tag with value ${JSON.stringify(value)} without modifying metadata`, async () => {
+            const file = await (0, _chai_spec_1.testImg)({ srcBasename: "with_faces.jpg" });
+            await expectNoModification(file, [
+                {
+                    tag: "XMP-mwg-rs:RegionList",
+                    operation: "remove",
+                    value,
+                },
+            ], /not supported/i);
+        });
+    }
+    it("rejects operations ExifTool cannot order without modifying metadata", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        await exiftool.write(file, { Subject: ["seed"] });
+        await expectNoModification(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "conflict",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "conflict",
+            },
+        ], /cannot preserve add-then-remove/i);
+    });
+    it("allows remove-then-add to normalize duplicate values", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        await exiftool.write(file, { Subject: ["forest", "keep", "forest"] });
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "forest",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+        ]);
+        const raw = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-dc:Subject"],
+        }));
+        (0, _chai_spec_1.expect)(raw["XMP-dc:Subject"]).to.be.an("array");
+        (0, _chai_spec_1.expect)([...raw["XMP-dc:Subject"]].sort()).to.eql([
+            "forest",
+            "keep",
+        ]);
+    });
+    it("normalizes duplicate IPTC values in one write", async () => {
+        const file = await (0, _chai_spec_1.testImg)({ srcBasename: "iptc.jpg" });
+        await exiftool.editTags(file, [
+            {
+                tag: "IPTC:Keywords",
+                operation: "remove",
+                value: "IPTC CORE : KEYWORDS",
+            },
+            { tag: "IPTC:Keywords", operation: "add", value: "forest" },
+            { tag: "IPTC:Keywords", operation: "add", value: "keep" },
+            { tag: "IPTC:Keywords", operation: "add", value: "forest" },
+        ]);
+        await exiftool.editTags(file, [
+            {
+                tag: "IPTC:Keywords",
+                operation: "remove",
+                value: "forest",
+            },
+            {
+                tag: "IPTC:Keywords",
+                operation: "add",
+                value: "forest",
+            },
+        ]);
+        // Bundled ExifTool 13.59 ground truth:
+        // exiftool -IPTC:Keywords-=forest -IPTC:Keywords+=forest file.jpg
+        // transforms [forest, keep, forest] to [forest, keep], not [keep, forest].
+        const raw = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-IPTC:Keywords"],
+        }));
+        (0, _chai_spec_1.expect)(raw["IPTC:Keywords"]).to.eql(["forest", "keep"]);
+    });
+    it("rejects ExifTool's list separator without modifying metadata", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        await exiftool.write(file, { Subject: ["a", "b", "keep"] });
+        await expectNoModification(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "a\u001fb",
+            },
+        ], /list separator/i);
+    });
+    it("rejects XML-invalid control characters without modifying metadata", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        await exiftool.write(file, { Subject: ["a.b", "keep"] });
+        await expectNoModification(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "a\u0001b",
+            },
+            {
+                tag: "XMP-dc:Subject",
+                operation: "remove",
+                value: "a.b",
+            },
+        ], /control character/i);
+    });
+    for (const value of ["a\ud800b", "a\ufffeb", "a\u{1ffff}b"]) {
+        it(`rejects non-round-tripping Unicode ${JSON.stringify(value)} without modifying metadata`, async () => {
+            const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+            await exiftool.write(file, { Subject: ["a???b", "keep"] });
+            await expectNoModification(file, [
+                {
+                    tag: "XMP-dc:Subject",
+                    operation: "remove",
+                    value,
+                },
+            ], /Unicode|character/i);
+        });
+    }
+    // ExifTool writes a literal CR byte, and its own reader hands it back
+    // unchanged, so only a conformant XML parser reveals the corruption.
+    for (const value of ["a\rb", "a\r\nb"]) {
+        it(`rejects the carriage return in ${JSON.stringify(value)} without modifying metadata`, async () => {
+            const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+            await exiftool.write(file, { Subject: ["keep"] });
+            await expectNoModification(file, [
+                {
+                    tag: "XMP-dc:Subject",
+                    operation: "add",
+                    value,
+                },
+            ], /carriage return/i);
+        });
+    }
+    it("preserves a leading ASCII space in primitive values", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: " leading",
+            },
+        ]);
+        const raw = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-dc:Subject"],
+        }));
+        (0, _chai_spec_1.expect)(raw["XMP-dc:Subject"]).to.include(" leading");
+    });
+    for (const writeArgs of [
+        ["-sep", ","],
+        ["-separator", ","],
+        ["-api", "ListSplit=,"],
+        ["-api", "NoDups=1"],
+    ]) {
+        it(`rejects edit-incompatible writeArgs ${JSON.stringify(writeArgs)} without modifying metadata`, async () => {
+            const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+            await exiftool.write(file, { Subject: ["a", "b", "keep", "a,b"] });
+            const before = await (0, _chai_spec_1.sha1)(file);
+            await (0, _chai_spec_1.expect)(exiftool.editTags(file, [
+                {
+                    tag: "XMP-dc:Subject",
+                    operation: "remove",
+                    value: "a,b",
+                },
+            ], { writeArgs })).to.be.rejectedWith(/writeArgs.*not compatible/i);
+            (0, _chai_spec_1.expect)(await (0, _chai_spec_1.sha1)(file)).to.eql(before);
+        });
+    }
+    it("preserves literal HTML entities in primitive values", async () => {
+        const file = await (0, _chai_spec_1.testFile)("keywords.xmp");
+        const values = ["A & B", "ab"];
+        await exiftool.editTags(file, values.map((value) => ({
+            tag: "XMP-dc:Subject",
+            operation: "add",
+            value,
+        })));
+        const raw = (await exiftool.readRaw(file, {
+            readArgs: ["-G1", "-XMP-dc:Subject"],
+        }));
+        for (const value of values) {
+            (0, _chai_spec_1.expect)(raw["XMP-dc:Subject"]).to.include(value);
+        }
+    });
+    it("requires canonical casing for a registered structured tag", async () => {
+        await (0, _chai_spec_1.expect)(exiftool.editTags(await (0, _chai_spec_1.testFile)("missing.jpg"), [
+            {
+                tag: "XMP-mwg-coll:collections",
+                operation: "remove",
+                value: "Vacation",
+            },
+        ])).to.be.rejectedWith(/canonical tag casing/i);
+    });
+    it("rejects an injected tag before accessing the target file", async () => {
+        await (0, _chai_spec_1.expect)(exiftool.editTags(await (0, _chai_spec_1.testFile)("missing.jpg"), [
+            {
+                tag: "XMP-dc:Subject\n-o\n../exploit",
+                operation: "remove",
+                value: "beach",
+            },
+        ])).to.be.rejectedWith(/invalid tag edit.*tag name|control character/i);
+    });
+    it("preserves WriteTaskOptions", async () => {
+        const file = await (0, _chai_spec_1.testImg)();
+        await exiftool.editTags(file, [
+            {
+                tag: "XMP-dc:Subject",
+                operation: "add",
+                value: "forest",
+            },
+        ], { writeArgs: ["-overwrite_original"] });
+        (0, _chai_spec_1.expect)((0, node_fs_1.existsSync)(file + "_original")).to.eql(false);
+    });
+});
+//# sourceMappingURL=TagEdit.spec.js.map