@schukai/monster 4.153.0 → 4.154.0

package/test/cases/components/time/month-calendar.mjs

@@ -70,6 +70,121 @@ describe("MonthCalendar date configuration", () => {
 		expect(currentDays(calendar)[0].month).to.equal(new Date().getMonth() + 1);
 		expect(calendar.getOption("calendarDays")).to.have.length(42);
 	});
+	describe("document language issue #578", () => {
+		// The oracle is Intl itself with an explicit tag, so none of these
+		// assertions depend on the locale of the machine running the suite.
+		const MONDAY = new Date(1970, 0, 5);
+		const weekdayIn = (tag, format) =>
+			new Intl.DateTimeFormat(tag, { weekday: format }).format(MONDAY);
+
+		let originalLang;
+
+		beforeEach(() => {
+			originalLang = document.documentElement.getAttribute("lang");
+		});
+
+		afterEach(() => {
+			if (originalLang === null) {
+				document.documentElement.removeAttribute("lang");
+			} else {
+				document.documentElement.setAttribute("lang", originalLang);
+			}
+		});
+
+		async function calendarFor(lang, format = "long") {
+			document.documentElement.setAttribute("lang", lang);
+			const calendar = document.createElement("monster-month-calendar");
+			calendar.setOption("startDate", "2026-10-01");
+			document.getElementById("mocks").append(calendar);
+			await updates();
+			calendar.setOption("locale.weekdayFormat", format);
+			await updates();
+			return calendar;
+		}
+
+		// net: the weekday header is always seven entries, indexed Monday first,
+		// and every label is a non empty string
+		it("produces seven indexed weekdays", async () => {
+			const calendar = await calendarFor("en");
+			const weekdays = calendar.getOption("calendarWeekdays");
+
+			expect(weekdays).to.have.length(7);
+			expect(weekdays.map((entry) => entry.index)).to.deep.equal([
+				0, 1, 2, 3, 4, 5, 6,
+			]);
+			for (const entry of weekdays) {
+				expect(entry.label).to.be.a("string").and.to.have.length.above(0);
+			}
+		});
+
+		it("rejects an invalid weekday format and falls back to short", async () => {
+			const calendar = await calendarFor("en", "bogus");
+			const weekdays = calendar.getOption("calendarWeekdays");
+
+			expect(calendar.hasAttribute(ATTRIBUTE_ERRORMESSAGE)).to.be.true;
+			// the short form is shorter than the long one, whatever the language
+			expect(weekdays[0].label.length).to.be.below(
+				weekdayIn("en", "long").length,
+			);
+		});
+
+		// net: this path reads locale.language, a string, and already works
+		it("translates the more-appointments label from the document language", async () => {
+			const calendar = await calendarFor("de");
+			const cell = calendar.shadowRoot.querySelector(
+				'[data-monster-day="2026-10-01"]',
+			);
+
+			expect(
+				cell.querySelector('[data-monster-role="more-appointments"]')
+					.textContent,
+			).to.contain("Weitere Termine");
+		});
+
+		// regression: Intl received the Locale instance instead of its tag, so the
+		// document language was ignored and the host system locale decided. At
+		// most one of these languages can match the machine locale, so the set is
+		// red before the fix in any environment.
+		for (const lang of ["ja", "de", "en", "es"]) {
+			it(`formats weekday names for lang="${lang}"`, async () => {
+				const calendar = await calendarFor(lang);
+
+				expect(calendar.getOption("calendarWeekdays")[0].label).to.equal(
+					weekdayIn(lang, "long"),
+				);
+			});
+		}
+
+		it("changes weekday names when the document language changes", async () => {
+			const japanese = await calendarFor("ja");
+			const japaneseLabel = japanese.getOption("calendarWeekdays")[0].label;
+
+			const spanish = await calendarFor("es");
+			const spanishLabel = spanish.getOption("calendarWeekdays")[0].label;
+
+			expect(japaneseLabel).to.equal(weekdayIn("ja", "long"));
+			expect(spanishLabel).to.equal(weekdayIn("es", "long"));
+			expect(japaneseLabel).to.not.equal(spanishLabel);
+		});
+
+		it("falls back to the short format in the document language", async () => {
+			const calendar = await calendarFor("ja", "bogus");
+
+			expect(calendar.hasAttribute(ATTRIBUTE_ERRORMESSAGE)).to.be.true;
+			expect(calendar.getOption("calendarWeekdays")[0].label).to.equal(
+				weekdayIn("ja", "short"),
+			);
+		});
+
+		it("honors the document language for the short format as well", async () => {
+			const calendar = await calendarFor("ja", "short");
+
+			expect(calendar.getOption("calendarWeekdays")[0].label).to.equal(
+				weekdayIn("ja", "short"),
+			);
+		});
+	});
+
 	it("keeps day interactions and weekday updates working after changing months", async () => {
 		const calendar = document.createElement("monster-month-calendar");
 		document.getElementById("mocks").append(calendar);

package/test/cases/data/buildmap.mjs

@@ -6,6 +6,20 @@ import {buildMap} from "../../../source/data/buildmap.mjs";
 
 describe('buildMap', function () {
 
+    describe('falsy keys and literal replacements issue #569', function () {
+        it('should preserve a zero key returned by a selector callback', function () {
+            const value = {label: 'zero'};
+            const map = buildMap({}, () => new Map([[0, value]]), '${label}');
+            expect([...map]).to.deep.equal([[0, 'zero']]);
+        });
+
+        it('should insert replacement tokens literally', function () {
+            const value = {label: '$&-$`-$\''};
+            const map = buildMap({}, () => new Map([['key', value]]), '${label}');
+            expect(map.get('key')).to.equal('$&-$`-$\'');
+        });
+    });
+
     let convertMapResult = function (r) {
         if (r instanceof Map) {
             r = Object.fromEntries(r);

package/test/cases/data/buildtree.mjs

@@ -170,6 +170,55 @@ describe('buildTree', function () {
 
     });
 
+    describe('parent metadata issue #568', function () {
+        const createTree = (records) => buildTree(
+            records,
+            (values) => new Map(values.map((value, index) => [index, value])),
+            'id',
+            'parent',
+        );
+
+        [
+            [
+                {id: 1, parent: null},
+                {id: 2, parent: 1},
+                {id: 3, parent: 2},
+            ],
+            [
+                {id: 3, parent: 2},
+                {id: 2, parent: 1},
+                {id: 1, parent: null},
+            ],
+        ].forEach((records, index) => {
+            it(`should retain immediate parents independent of input order ${index + 1}`, function () {
+                const tree = createTree(records);
+                const root = [...tree][0];
+                const child = [...root.childNodes][0];
+                const leaf = [...child.childNodes][0];
+
+                expect(root.parent).to.equal(null);
+                expect(root.level).to.equal(0);
+                expect(child.parent).to.equal(root);
+                expect(child.level).to.equal(1);
+                expect(leaf.parent).to.equal(child);
+                expect(leaf.level).to.equal(2);
+            });
+        });
+
+        it('should preserve frozen input records and their identity', function () {
+            const rootValue = Object.freeze({id: 1, parent: null});
+            const childValue = Object.freeze({id: 2, parent: 1});
+            const tree = createTree(Object.freeze([childValue, rootValue]));
+            const root = [...tree][0];
+            const child = [...root.childNodes][0];
+
+            expect(root.value).to.equal(rootValue);
+            expect(child.value).to.equal(childValue);
+            expect(Reflect.ownKeys(rootValue)).to.deep.equal(['id', 'parent']);
+            expect(Reflect.ownKeys(childValue)).to.deep.equal(['id', 'parent']);
+        });
+    });
+
     describe('buildTree() test 2', function () {
 
         /**

package/test/cases/data/diff.mjs

@@ -285,4 +285,90 @@ describe('Diff', function () {
 
     });
 
+    describe('numeric identity issue #571', function () {
+
+        // net: these describe behaviour that is already correct today
+        it('should report an update when NaN is replaced by a number', function () {
+            let d = diff({a: NaN}, {a: 1});
+            expect(d.length).is.equal(1);
+            expect(d[0].operator).is.equal('update');
+            expect(d[0].path).is.eql(['a']);
+        });
+
+        it('should report an update when a number is replaced by NaN', function () {
+            let d = diff({a: 1}, {a: NaN});
+            expect(d.length).is.equal(1);
+            expect(d[0].operator).is.equal('update');
+            expect(d[0].path).is.eql(['a']);
+        });
+
+        it('should keep treating 0 and -0 as equal', function () {
+            expect(JSON.stringify(diff({a: 0}, {a: -0}))).is.equal('[]');
+            expect(JSON.stringify(diff({a: -0}, {a: 0}))).is.equal('[]');
+        });
+
+        // regression: two equal NaN values are not a change
+        it('should not report a change for two NaN values at the same path', function () {
+            expect(JSON.stringify(diff({a: NaN}, {a: NaN}))).is.equal('[]');
+        });
+
+        it('should not report a change for nested NaN values', function () {
+            let first = {a: {b: NaN}, c: {d: {e: NaN}}};
+            let second = {a: {b: NaN}, c: {d: {e: NaN}}};
+            expect(JSON.stringify(diff(first, second))).is.equal('[]');
+        });
+
+        it('should not report a change for NaN inside an unchanged array', function () {
+            expect(JSON.stringify(diff([NaN, 1], [NaN, 1]))).is.equal('[]');
+        });
+
+        it('should not report a change for a NaN value reached through a wildcard shaped tree', function () {
+            let first = {rows: [{value: NaN}, {value: 2}]};
+            let second = {rows: [{value: NaN}, {value: 2}]};
+            expect(JSON.stringify(diff(first, second))).is.equal('[]');
+        });
+    })
+
+    describe('array key handling issue #574', function () {
+
+        // net: array indices are reported as string path segments. getKeys() has a
+        // dead numeric-index branch; replacing it would turn ["0"] into [0] and
+        // change every array diff path, so these pin the contract first.
+        it('should report deletions with string index paths when an array shrinks', function () {
+            let d = diff({a: [1, 2, 3]}, {a: [1]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"delete","path":["a","1"],"first":{"value":2,"type":"number"}},{"operator":"delete","path":["a","2"],"first":{"value":3,"type":"number"}}]');
+        });
+
+        it('should report additions with string index paths when an array grows', function () {
+            let d = diff({a: [1]}, {a: [1, 2]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"add","path":["a","1"],"second":{"value":2,"type":"number"}}]');
+        });
+
+        it('should report an update with a string index path when an element changes', function () {
+            let d = diff({a: [1, 2]}, {a: [1, 9]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"update","path":["a","1"],"first":{"value":2,"type":"number"},"second":{"value":9,"type":"number"}}]');
+        });
+
+        it('should report no change for identical arrays', function () {
+            expect(JSON.stringify(diff({a: [1, 2, 3]}, {a: [1, 2, 3]}))).is.equal('[]');
+        });
+
+        it('should diff nested arrays of objects with string index paths', function () {
+            let d = diff({rows: [{id: 1}, {id: 2}]}, {rows: [{id: 1}, {id: 3}]});
+
+            expect(JSON.stringify(d)).is.equal('[{"operator":"update","path":["rows","1","id"],"first":{"value":2,"type":"number"},"second":{"value":3,"type":"number"}}]');
+        });
+
+        it('should treat a sparse array hole as absent rather than as undefined', function () {
+            let sparse = [1];
+            sparse[2] = 3;
+
+            expect(JSON.stringify(diff({a: sparse}, {a: sparse}))).is.equal('[]');
+            expect(Object.hasOwn(sparse, '1')).to.be.false;
+        });
+    })
+
 })

package/test/cases/data/extend.mjs

@@ -183,6 +183,58 @@ describe('extend function', () => {
             }
         });
     });
+
+    // net: behaviour that is already correct and must stay correct
+    it('should keep merging nested objects without losing existing keys issue #573', () => {
+        const target = { a: { b: 1, keep: 'yes' } };
+        const source = { a: { c: 2 } };
+
+        expect(extend(target, source)).to.deep.equal({ a: { b: 1, c: 2, keep: 'yes' } });
+    });
+
+    it('should keep throwing on a type mismatch issue #573', () => {
+        expect(() => extend({ a: { b: 1 } }, { a: [1, 2] })).to.throw();
+        expect(() => extend({ a: [1, 2] }, { a: { b: 1 } })).to.throw();
+    });
+
+    it('should keep throwing for unsupported arguments issue #573', () => {
+        expect(() => extend({ a: 1 }, 'not an object')).to.throw();
+        expect(() => extend(null, { a: 1 })).to.throw();
+    });
+
+    // regression: a cyclic source must terminate instead of exhausting the stack
+    it('should extend from a self referencing source issue #573', () => {
+        const source = { name: 'root' };
+        source.self = source;
+
+        const result = extend({}, source);
+
+        expect(result.name).to.equal('root');
+        expect(result.self).to.be.an('object');
+        expect(result.self.name).to.equal('root');
+    });
+
+    it('should extend from a mutual reference between two sources issue #573', () => {
+        const first = { name: 'first' };
+        const second = { name: 'second', first };
+        first.second = second;
+
+        const result = extend({}, first);
+
+        expect(result.name).to.equal('first');
+        expect(result.second.name).to.equal('second');
+        expect(result.second.first).to.be.an('object');
+    });
+
+    it('should extend from a cycle that runs through an array issue #573', () => {
+        const source = { items: [] };
+        source.items.push(source);
+
+        const result = extend({}, source);
+
+        expect(result.items).to.be.an('array');
+        expect(result.items.length).to.equal(1);
+    });
 });
 
 

package/test/cases/data/pathfinder-resolution-baseline.mjs

@@ -0,0 +1,322 @@
+"use strict";
+
+import {expect} from "chai"
+import {Pathfinder} from "../../../source/data/pathfinder.mjs";
+
+/**
+ * Baseline for issue #576.
+ *
+ * getOption() is called about 1393 times across the library and resolves every
+ * option through Pathfinder, today by throwing and catching. Before that read
+ * path is replaced, this file freezes the resolution semantics that callers
+ * depend on. Every assertion here passes with the old implementation and must
+ * keep passing with the new one.
+ */
+describe('Pathfinder resolution baseline issue #576', function () {
+
+    class WithPrototypeMember {
+        constructor() {
+            this.own = 1;
+        }
+
+        inherited() {
+        }
+    }
+
+    function buildSubject() {
+        const nullProto = Object.create(null);
+        nullProto.leaf = 'from-null-proto';
+
+        return {
+            flat: 'value',
+            zero: 0,
+            emptyString: '',
+            falseValue: false,
+            nullValue: null,
+            undefinedValue: undefined,
+            nested: {
+                deep: {
+                    leaf: 'deep-leaf',
+                },
+                list: ['first', 'second', 'third'],
+                objects: [{id: 1}, {id: 2}],
+            },
+            map: new Map([['key', 'map-value'], ['nested', {leaf: 'map-leaf'}]]),
+            set: new Set(['set-first', 'set-second']),
+            instance: new WithPrototypeMember(),
+            nullProto,
+        };
+    }
+
+    describe('getVia() resolved values', function () {
+
+        [
+            ['flat', 'value'],
+            ['zero', 0],
+            ['emptyString', ''],
+            ['falseValue', false],
+            ['nullValue', null],
+            ['undefinedValue', undefined],
+            ['nested.deep.leaf', 'deep-leaf'],
+            ['nested.list.0', 'first'],
+            ['nested.list.2', 'third'],
+            ['nested.objects.1.id', 2],
+            ['map.key', 'map-value'],
+            ['map.nested.leaf', 'map-leaf'],
+            ['set.0', 'set-first'],
+            ['set.1', 'set-second'],
+            ['instance.own', 1],
+            ['nullProto.leaf', 'from-null-proto'],
+        ].forEach(function (data) {
+            const path = data[0];
+            const expected = data[1];
+
+            it(`getVia(${path}) should resolve to ${JSON.stringify(expected)}`, function () {
+                expect(new Pathfinder(buildSubject()).getVia(path)).to.equal(expected);
+            });
+        });
+
+        it('getVia() should resolve a prototype member', function () {
+            const value = new Pathfinder(buildSubject()).getVia('instance.inherited');
+            expect(typeof value).to.equal('function');
+        });
+
+        it('getVia() should return the root for an empty path', function () {
+            const subject = buildSubject();
+            expect(new Pathfinder(subject).getVia('')).to.equal(subject);
+            expect(new Pathfinder(subject).getVia([])).to.equal(subject);
+        });
+
+        it('getVia() should accept an array path and not mutate it', function () {
+            const path = ['nested', 'deep', 'leaf'];
+            expect(new Pathfinder(buildSubject()).getVia(path)).to.equal('deep-leaf');
+            expect(path).to.deep.equal(['nested', 'deep', 'leaf']);
+        });
+    });
+
+    describe('getVia() missing leaves resolve to undefined', function () {
+
+        [
+            'missing',
+            'nested.missing',
+            'nested.deep.missing',
+            'map.missing',
+        ].forEach(function (path) {
+            it(`getVia(${path}) should resolve to undefined`, function () {
+                expect(new Pathfinder(buildSubject()).getVia(path)).to.equal(undefined);
+            });
+        });
+    });
+
+    describe('getVia() throws past a non traversable value', function () {
+
+        [
+            'flat.deeper',
+            'zero.deeper',
+            'nested.deep.leaf.deeper',
+            'undefinedValue.deeper',
+            'nullValue.deeper',
+            'nested.list.0.deeper',
+        ].forEach(function (path) {
+            it(`getVia(${path}) should throw`, function () {
+                expect(() => new Pathfinder(buildSubject()).getVia(path)).to.throw();
+            });
+        });
+
+        it('should report that the journey is not at its end', function () {
+            expect(() => new Pathfinder(buildSubject()).getVia('flat.deeper'))
+                .to.throw(Error, 'the journey is not at its end');
+        });
+
+        it('should reject an index with trailing characters', function () {
+            expect(() => new Pathfinder(buildSubject()).getVia('nested.list.1suffix'))
+                .to.throw(TypeError, 'value is not an integer');
+            expect(() => new Pathfinder(buildSubject()).getVia('set.1suffix'))
+                .to.throw(TypeError, 'value is not an integer');
+        });
+
+        it('should reject unsupported weak collections', function () {
+            expect(() => new Pathfinder({weak: new WeakSet()}).getVia('weak.entry'))
+                .to.throw(Error, 'unsupported action for this data type (WeakSet)');
+        });
+
+        it('should reject a non string and non array path', function () {
+            expect(() => new Pathfinder(buildSubject()).getVia(42)).to.throw(Error);
+            expect(() => new Pathfinder(buildSubject()).getVia(undefined)).to.throw(Error);
+            expect(() => new Pathfinder(buildSubject()).getVia(null)).to.throw(Error);
+        });
+    });
+
+    describe('exists() membership semantics', function () {
+
+        [
+            ['flat', true],
+            ['zero', true],
+            ['emptyString', true],
+            ['falseValue', true],
+            ['nullValue', true],
+            ['undefinedValue', true],
+            ['missing', false],
+            ['nested.deep.leaf', true],
+            ['nested.deep.missing', false],
+            ['nested.missing.leaf', false],
+            ['nested.list.0', true],
+            ['nested.list.2', true],
+            ['nested.list.3', false],
+            ['nested.objects.1.id', true],
+            ['map.key', true],
+            ['map.missing', false],
+            ['set.0', true],
+            ['set.1', true],
+            ['set.2', false],
+            ['instance.own', true],
+            ['instance.inherited', true],
+            ['nullProto.leaf', true],
+            ['nullProto.missing', false],
+            ['flat.deeper', false],
+        ].forEach(function (data) {
+            const path = data[0];
+            const expected = data[1];
+
+            it(`exists(${path}) should be ${expected}`, function () {
+                expect(new Pathfinder(buildSubject()).exists(path)).to.equal(expected);
+            });
+        });
+
+        it('exists() should report a present key whose value is undefined', function () {
+            expect(new Pathfinder({a: {b: undefined}}).exists('a.b')).to.equal(true);
+            expect(new Pathfinder({a: {b: undefined}}).exists('a.c')).to.equal(false);
+        });
+
+        // load bearing: init-options-from-attributes.mjs and
+        // set-option-from-attribute.mjs call exists() with an undefined option
+        // name for every unknown data-monster-option-* attribute
+        it('exists() should return false instead of throwing for a malformed path', function () {
+            const pathfinder = new Pathfinder(buildSubject());
+
+            expect(pathfinder.exists(undefined)).to.equal(false);
+            expect(pathfinder.exists(null)).to.equal(false);
+            expect(pathfinder.exists(42)).to.equal(false);
+            expect(pathfinder.exists({})).to.equal(false);
+            expect(pathfinder.exists('nested.list.1suffix')).to.equal(false);
+        });
+
+        it('exists() should accept an array path', function () {
+            expect(new Pathfinder(buildSubject()).exists(['nested', 'deep', 'leaf'])).to.equal(true);
+            expect(new Pathfinder(buildSubject()).exists(['nested', 'deep', 'nope'])).to.equal(false);
+        });
+    });
+
+    describe('setVia() vivification', function () {
+
+        it('should build nested objects', function () {
+            const subject = {};
+            new Pathfinder(subject).setVia('a.b.c', true);
+            expect(JSON.stringify(subject)).to.equal('{"a":{"b":{"c":true}}}');
+        });
+
+        it('should build a sparse array for an integer segment', function () {
+            const subject = {};
+            new Pathfinder(subject).setVia('a.b.3.c', true);
+            expect(JSON.stringify(subject)).to.equal('{"a":{"b":[null,null,null,{"c":true}]}}');
+        });
+
+        it('should build nested arrays', function () {
+            const subject = {};
+            new Pathfinder(subject).setVia('a.b.0.0.c', true);
+            expect(JSON.stringify(subject)).to.equal('{"a":{"b":[[{"c":true}]]}}');
+        });
+
+        it('should add to a Set and ignore the key', function () {
+            const values = new Set(['first']);
+            new Pathfinder({values}).setVia('values.anything', 'second');
+            expect([...values]).to.deep.equal(['first', 'second']);
+        });
+
+        it('should write into a Map', function () {
+            const map = new Map();
+            new Pathfinder({map}).setVia('map.key', 'written');
+            expect(map.get('key')).to.equal('written');
+        });
+
+        it('should reject a WeakSet write explicitly', function () {
+            expect(() => new Pathfinder({values: new WeakSet()}).setVia('values.next', {}))
+                .to.throw(Error, 'unsupported action for this data type in setValueViaPath');
+        });
+
+        it('should reject unsafe mutation path segments', function () {
+            expect(() => new Pathfinder({}).setVia('__proto__.polluted', true)).to.throw(Error);
+            expect(() => new Pathfinder({}).setVia('constructor.prototype.polluted', true)).to.throw(Error);
+        });
+    });
+
+    describe('wildcard resolution', function () {
+
+        function wildcardSubject() {
+            return {
+                a: {
+                    b: {leaf: 1},
+                    c: {leaf: 2},
+                },
+                rows: [{value: 'x'}, {value: 'y'}],
+                map: new Map([['first', {leaf: 'm1'}], ['second', {leaf: 'm2'}]]),
+                set: new Set(['s1', 's2']),
+            };
+        }
+
+        it('should return a Map for a trailing wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('a.*');
+            expect(result).to.be.instanceOf(Map);
+            expect([...result.keys()]).to.deep.equal(['b', 'c']);
+        });
+
+        it('should resolve a path behind a wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('a.*.leaf');
+            expect(Array.from(result)).to.deep.equal([['b', 1], ['c', 2]]);
+        });
+
+        it('should enumerate array entries behind a wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('rows.*.value');
+            expect(Array.from(result)).to.deep.equal([['0', 'x'], ['1', 'y']]);
+        });
+
+        it('should enumerate Map values behind a wildcard', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('map.*.leaf');
+            expect(Array.from(result)).to.deep.equal([['first', 'm1'], ['second', 'm2']]);
+        });
+
+        it('should enumerate Set values behind a wildcard with stringified indices', function () {
+            const result = new Pathfinder(wildcardSubject()).getVia('set.*');
+            expect(Array.from(result)).to.deep.equal([['0', 's1'], ['1', 's2']]);
+        });
+
+        it('should support a leading wildcard', function () {
+            const result = new Pathfinder({a: {x: 1}, b: {x: 2}}).getVia('*.x');
+            expect(Array.from(result)).to.deep.equal([['a', 1], ['b', 2]]);
+        });
+
+        it('exists() should work through a wildcard', function () {
+            expect(new Pathfinder(wildcardSubject()).exists('a.*.leaf')).to.equal(true);
+        });
+    });
+
+    describe('deleteVia()', function () {
+
+        it('should delete an object key', function () {
+            const subject = {a: {b: 1, c: 2}};
+            new Pathfinder(subject).deleteVia('a.b');
+            expect(subject).to.deep.equal({a: {c: 2}});
+        });
+
+        it('should delete a Map entry', function () {
+            const map = new Map([['key', 1]]);
+            new Pathfinder({map}).deleteVia('map.key');
+            expect(map.has('key')).to.equal(false);
+        });
+
+        it('should reject deleting from a Set', function () {
+            expect(() => new Pathfinder({values: new Set(['a'])}).deleteVia('values.0'))
+                .to.throw(Error, 'unsupported action for this data type in deleteValueViaPath');
+        });
+    });
+});