@player-ui/partial-match-registry 0.15.3 → 0.15.4--canary.881.37421

package/dist/Registry.native.js

@@ -81,6 +81,23 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var Registry = function() {
+    var createNewSortInstance = function createNewSortInstance(opts) {
+        var comparer = castComparer(opts.comparer);
+        return function(arrayToSort) {
+            var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting ? arrayToSort.slice() : arrayToSort;
+            return {
+                asc: function asc(sortBy) {
+                    return sortArray(1, ctx, sortBy, comparer);
+                },
+                desc: function desc(sortBy) {
+                    return sortArray(-1, ctx, sortBy, comparer);
+                },
+                by: function by(sortBy) {
+                    return sortArray(1, ctx, sortBy, comparer);
+                }
+            };
+        };
+    };
     var dlv_es_default = // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/dlv@1.1.3/node_modules/dlv/dist/dlv.es.js
     function dlv_es_default(t, e, l, n, r) {
         for(e = e.split ? e.split(".") : e, n = 0; n < e.length; n++)t = t ? t[e[n]] : r;
@@ -88,7 +105,7 @@ var Registry = function() {
     };
     var createObjectMatcher = function createObjectMatcher(partialObj) {
         var pairs = traverseObj(partialObj);
-        var matchFunction = function matchFunction(searchObj) {
+        var matchFunction = function(searchObj) {
             var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
                 for(var _iterator = Array.from(pairs)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
@@ -119,39 +136,30 @@ var Registry = function() {
     };
     var createBasicMatcher = // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts
     function createBasicMatcher(seed) {
-        var matcher = function matcher(match) {
+        var matcher = function(match) {
             return seed === match;
         };
         matcher.count = 1;
         return matcher;
     };
-    var __create = Object.create;
     var __defProp = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames = Object.getOwnPropertyNames;
-    var __getProtoOf = Object.getPrototypeOf;
     var __hasOwnProp = Object.prototype.hasOwnProperty;
-    var __commonJS = function __commonJS(cb, mod) {
-        return function __require() {
-            return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
-                exports: {}
-            }).exports, mod), mod.exports;
-        };
-    };
-    var __export = function __export(target, all) {
+    var __export = function(target, all) {
         for(var name in all)__defProp(target, name, {
             get: all[name],
             enumerable: true
         });
     };
-    var __copyProps = function __copyProps(to, from, except, desc) {
+    var __copyProps = function(to, from, except, desc) {
         if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
             var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
                 var _loop = function() {
                     var key = _step.value;
                     if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-                        get: function get() {
+                        get: function() {
                             return from[key];
                         },
                         enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
@@ -175,113 +183,117 @@ var Registry = function() {
         }
         return to;
     };
-    var __toESM = function __toESM(mod, isNodeMode, target) {
-        return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
-        // file that has been converted to a CommonJS file using a Babel-
-        // compatible transform (i.e. "__esModule" has not been set), then set
-        // "default" to the CommonJS "module.exports" for node compatibility.
-        isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-            value: mod,
-            enumerable: true
-        }) : target, mod);
-    };
-    var __toCommonJS = function __toCommonJS(mod) {
+    var __toCommonJS = function(mod) {
         return __copyProps(__defProp({}, "__esModule", {
             value: true
         }), mod);
     };
-    // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/sorted-array@2.0.4/node_modules/sorted-array/sorted-array.js
-    var require_sorted_array = __commonJS({
-        "../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/sorted-array@2.0.4/node_modules/sorted-array/sorted-array.js": function(exports, module) {
-            "use strict";
-            var SortedArray2 = function() {
-                var SortedArray3 = defclass({
-                    constructor: function constructor(array, compare) {
-                        this.array = [];
-                        this.compare = compare || compareDefault;
-                        var length = array.length, index = 0;
-                        while(index < length)this.insert(array[index++]);
-                    },
-                    insert: function insert(element) {
-                        var array = this.array, compare = this.compare, high = array.length - 1, low = 0, pos = -1, index, ordering;
-                        while(high >= low){
-                            index = (high + low) / 2 >>> 0;
-                            ordering = compare(array[index], element);
-                            if (ordering < 0) low = index + 1;
-                            else if (ordering > 0) high = index - 1;
-                            else {
-                                pos = index;
-                                break;
-                            }
-                            ;
-                        }
-                        if (pos === -1) {
-                            pos = high;
-                        }
-                        pos++;
-                        high = array.length - 1;
-                        while(pos < high && compare(element, array[pos]) === 0){
-                            pos++;
-                        }
-                        index = array.length;
-                        array.push(element);
-                        while(index > pos){
-                            array[index] = array[--index];
-                        }
-                        array[pos] = element;
-                        return this;
-                    },
-                    search: function search(element) {
-                        var array = this.array, compare = this.compare, high = array.length - 1, low = 0, index, ordering;
-                        while(high >= low){
-                            index = (high + low) / 2 >>> 0;
-                            ordering = compare(array[index], element);
-                            if (ordering < 0) low = index + 1;
-                            else if (ordering > 0) high = index - 1;
-                            else return index;
-                        }
-                        return -1;
-                    },
-                    remove: function remove(element) {
-                        var index = this.search(element);
-                        if (index >= 0) this.array.splice(index, 1);
-                        return this;
-                    }
-                });
-                SortedArray3.comparing = function(property, array) {
-                    return new SortedArray3(array, function(a, b) {
-                        return compareDefault(a[property], b[property]);
-                    });
-                };
-                return SortedArray3;
-                function defclass(prototype) {
-                    var constructor = prototype.constructor;
-                    constructor.prototype = prototype;
-                    return constructor;
-                }
-                function compareDefault(a, b) {
-                    if (a < b) return -1;
-                    else if (a > b) return 1;
-                    else return 0;
-                }
-            }();
-            if ((typeof module === "undefined" ? "undefined" : _type_of(module)) === "object") module.exports = SortedArray2;
-            if (typeof define === "function" && define.amd) define(function() {
-                return SortedArray2;
-            });
-        }
-    });
     // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts
     var src_exports = {};
     __export(src_exports, {
-        Registry: function Registry1() {
+        Registry: function() {
             return Registry;
         },
-        createObjectMatcher: function createObjectMatcher1() {
+        createObjectMatcher: function() {
             return createObjectMatcher;
         }
     });
-    var import_sorted_array = __toESM(require_sorted_array());
+    // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/fast-sort@3.4.1/node_modules/fast-sort/dist/sort.mjs
+    var castComparer = function castComparer(comparer) {
+        return function(a, b, order) {
+            return comparer(a, b, order) * order;
+        };
+    };
+    var throwInvalidConfigErrorIfTrue = function throwInvalidConfigErrorIfTrue(condition, context) {
+        if (condition) throw Error("Invalid sort config: " + context);
+    };
+    var unpackObjectSorter = function unpackObjectSorter(sortByObj) {
+        var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;
+        var order = asc ? 1 : -1;
+        var sortBy = asc || desc;
+        throwInvalidConfigErrorIfTrue(!sortBy, "Expected `asc` or `desc` property");
+        throwInvalidConfigErrorIfTrue(asc && desc, "Ambiguous object with `asc` and `desc` config properties");
+        var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);
+        return {
+            order: order,
+            sortBy: sortBy,
+            comparer: comparer
+        };
+    };
+    var multiPropertySorterProvider = function multiPropertySorterProvider(defaultComparer2) {
+        return function multiPropertySorter(sortBy, sortByArr, depth, order, comparer, a, b) {
+            var valA;
+            var valB;
+            if (typeof sortBy === "string") {
+                valA = a[sortBy];
+                valB = b[sortBy];
+            } else if (typeof sortBy === "function") {
+                valA = sortBy(a);
+                valB = sortBy(b);
+            } else {
+                var objectSorterConfig = unpackObjectSorter(sortBy);
+                return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer2, a, b);
+            }
+            var equality = comparer(valA, valB, order);
+            if ((equality === 0 || valA == null && valB == null) && sortByArr.length > depth) {
+                return multiPropertySorter(sortByArr[depth], sortByArr, depth + 1, order, comparer, a, b);
+            }
+            return equality;
+        };
+    };
+    function getSortStrategy(sortBy, comparer, order) {
+        if (sortBy === void 0 || sortBy === true) {
+            return function(a, b) {
+                return comparer(a, b, order);
+            };
+        }
+        if (typeof sortBy === "string") {
+            throwInvalidConfigErrorIfTrue(sortBy.includes("."), "String syntax not allowed for nested properties.");
+            return function(a, b) {
+                return comparer(a[sortBy], b[sortBy], order);
+            };
+        }
+        if (typeof sortBy === "function") {
+            return function(a, b) {
+                return comparer(sortBy(a), sortBy(b), order);
+            };
+        }
+        if (Array.isArray(sortBy)) {
+            var multiPropSorter_1 = multiPropertySorterProvider(comparer);
+            return function(a, b) {
+                return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b);
+            };
+        }
+        var objectSorterConfig = unpackObjectSorter(sortBy);
+        return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);
+    }
+    var sortArray = function sortArray(order, ctx, sortBy, comparer) {
+        var _a;
+        if (!Array.isArray(ctx)) {
+            return ctx;
+        }
+        if (Array.isArray(sortBy) && sortBy.length < 2) {
+            _a = sortBy, sortBy = _a[0];
+        }
+        return ctx.sort(getSortStrategy(sortBy, comparer, order));
+    };
+    var defaultComparer = function defaultComparer(a, b, order) {
+        if (a == null) return order;
+        if (b == null) return -order;
+        if ((typeof a === "undefined" ? "undefined" : _type_of(a)) !== (typeof b === "undefined" ? "undefined" : _type_of(b))) {
+            return (typeof a === "undefined" ? "undefined" : _type_of(a)) < (typeof b === "undefined" ? "undefined" : _type_of(b)) ? -1 : 1;
+        }
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    };
+    var sort = createNewSortInstance({
+        comparer: defaultComparer
+    });
+    var inPlaceSort = createNewSortInstance({
+        comparer: defaultComparer,
+        inPlaceSorting: true
+    });
     // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts
     function traverseObj(object) {
         var path = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], pairs = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : /* @__PURE__ */ new Map();
@@ -293,7 +305,7 @@ var Registry = function() {
                 var nestedPath = _to_consumable_array(path).concat([
                     key
                 ]);
-                if ((typeof val === "undefined" ? "undefined" : _type_of(val)) === "object") {
+                if ((typeof val === "undefined" ? "undefined" : _type_of(val)) === "object" && val !== null) {
                     traverseObj(val, nestedPath, pairs);
                 } else {
                     pairs.set(nestedPath, val);
@@ -315,16 +327,12 @@ var Registry = function() {
         }
         return pairs;
     }
-    var createSortedArray = function createSortedArray() {
-        return new import_sorted_array.default([], function(c) {
-            return c.matcher.count;
-        });
-    };
     var Registry = /*#__PURE__*/ function() {
-        function Registry(initialSet) {
+        function Registry(initialSet, logger) {
             var _this = this;
             _class_call_check(this, Registry);
-            this.store = createSortedArray();
+            this.store = [];
+            this.logger = logger;
             initialSet === null || initialSet === void 0 ? void 0 : initialSet.forEach(function(param) {
                 var _param = _sliced_to_array(param, 2), match = _param[0], value = _param[1];
                 _this.set(match, value);
@@ -332,22 +340,50 @@ var Registry = function() {
         }
         _create_class(Registry, [
             {
-                /** Add match -> value mapping to the registry */ key: "set",
+                /**
+     * Add match -> value mapping to the registry
+     *
+     * If an entry with the same specificity and matching key already exists, it will be replaced
+     * and a debug log will be emitted (if a logger is configured).
+     *
+     * @param match - The key to match against (can be a primitive or object)
+     * @param value - The value to associate with this key
+     */ key: "set",
                 value: function set(match, value) {
                     var matcher = (typeof match === "undefined" ? "undefined" : _type_of(match)) === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-                    this.store.insert({
+                    var existingIndex = this.store.findIndex(function(entry) {
+                        return entry.matcher(match) && matcher(entry.key);
+                    });
+                    if (existingIndex !== -1) {
+                        var _this_logger_debug, _this_logger;
+                        this.store.splice(existingIndex, 1);
+                        (_this_logger = this.logger) === null || _this_logger === void 0 ? void 0 : (_this_logger_debug = _this_logger.debug) === null || _this_logger_debug === void 0 ? void 0 : _this_logger_debug.call(_this_logger, "Registry: Replacing existing entry for key ", match);
+                    }
+                    this.store.push({
                         key: match,
                         value: value,
                         matcher: matcher
                     });
+                    this.store = sort(this.store).desc(function(entry) {
+                        return entry.matcher.count;
+                    });
                 }
             },
             {
-                /** Fetch the best match in the registry */ key: "get",
+                /**
+     * Fetch the best match in the registry
+     *
+     * Searches for the most specific entry that matches the given query.
+     * The registry is sorted by specificity (matcher.count) in descending order,
+     * so we iterate forward to find the highest specificity match first.
+     *
+     * @param query - The query object to match against registered keys
+     * @returns The value associated with the best matching key, or undefined if no match found
+     */ key: "get",
                 value: function get(query) {
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
-                        for(var _iterator = this.store.array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        for(var _iterator = this.store[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             var entry = _step.value;
                             if (entry.matcher(query)) {
                                 return entry.value;
@@ -367,6 +403,7 @@ var Registry = function() {
                             }
                         }
                     }
+                    return void 0;
                 }
             },
             {
@@ -374,7 +411,7 @@ var Registry = function() {
                 value: function forEach(callbackfn) {
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
-                        for(var _iterator = this.store.array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        for(var _iterator = this.store[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             var entry = _step.value;
                             callbackfn(entry);
                         }
@@ -397,13 +434,13 @@ var Registry = function() {
             {
                 /** Reset the items in the registry */ key: "clear",
                 value: function clear() {
-                    this.store = createSortedArray();
+                    this.store = [];
                 }
             },
             {
                 /** Check if the registry is empty*/ key: "isRegistryEmpty",
                 value: function isRegistryEmpty() {
-                    return this.store.array.length === 0;
+                    return this.store.length === 0;
                 }
             }
         ]);

package/dist/Registry.native.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/circleci/.cache/bazel/_bazel_circleci/e8362d362e14c7d23506d1dfa3aea8b8/sandbox/processwrapper-sandbox/2260/execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/dist/index.global.js","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/dlv@1.1.3/node_modules/dlv/index.js","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/sorted-array@2.0.4/node_modules/sorted-array/sorted-array.js"],"names":["Registry","dlv_es_default","obj","key","def","p","undef","split","length","createObjectMatcher","partialObj","pairs","traverseObj","matchFunction","searchObj","Array","from","entry","path","value","count","size","createBasicMatcher","seed","matcher","match","__create","Object","create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","prototype","hasOwnProperty","__commonJS","cb","mod","__require","exports","__export","target","all","name","get","enumerable","__copyProps","to","except","desc","call","__toESM","isNodeMode","__esModule","__toCommonJS","require_sorted_array","module","SortedArray","defclass","array","compare","compareDefault","index","insert","element","high","low","pos","ordering","push","search","remove","splice","comparing","property","a","b","constructor","define","amd","src_exports","import_sorted_array","object","Map","keys","val","nestedPath","set","createSortedArray","c","initialSet","store","forEach","query","callbackfn","clear","isRegistryEmpty"],"mappings":"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","sourcesContent":["\"use strict\";\nvar Registry = (() => {\n  var __create = Object.create;\n  var __defProp = Object.defineProperty;\n  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;\n  var __getOwnPropNames = Object.getOwnPropertyNames;\n  var __getProtoOf = Object.getPrototypeOf;\n  var __hasOwnProp = Object.prototype.hasOwnProperty;\n  var __commonJS = (cb, mod) => function __require() {\n    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n  };\n  var __export = (target, all) => {\n    for (var name in all)\n      __defProp(target, name, { get: all[name], enumerable: true });\n  };\n  var __copyProps = (to, from, except, desc) => {\n    if (from && typeof from === \"object\" || typeof from === \"function\") {\n      for (let key of __getOwnPropNames(from))\n        if (!__hasOwnProp.call(to, key) && key !== except)\n          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n    }\n    return to;\n  };\n  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n    // If the importer is in node compatibility mode or this is not an ESM\n    // file that has been converted to a CommonJS file using a Babel-\n    // compatible transform (i.e. \"__esModule\" has not been set), then set\n    // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n    isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n    mod\n  ));\n  var __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/sorted-array@2.0.4/node_modules/sorted-array/sorted-array.js\n  var require_sorted_array = __commonJS({\n    \"../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/sorted-array@2.0.4/node_modules/sorted-array/sorted-array.js\"(exports, module) {\n      \"use strict\";\n      var SortedArray2 = function() {\n        var SortedArray3 = defclass({\n          constructor: function(array, compare) {\n            this.array = [];\n            this.compare = compare || compareDefault;\n            var length = array.length, index = 0;\n            while (index < length)\n              this.insert(array[index++]);\n          },\n          insert: function(element) {\n            var array = this.array, compare = this.compare, high = array.length - 1, low = 0, pos = -1, index, ordering;\n            while (high >= low) {\n              index = (high + low) / 2 >>> 0;\n              ordering = compare(array[index], element);\n              if (ordering < 0)\n                low = index + 1;\n              else if (ordering > 0)\n                high = index - 1;\n              else {\n                pos = index;\n                break;\n              }\n              ;\n            }\n            if (pos === -1) {\n              pos = high;\n            }\n            pos++;\n            high = array.length - 1;\n            while (pos < high && compare(element, array[pos]) === 0) {\n              pos++;\n            }\n            index = array.length;\n            array.push(element);\n            while (index > pos) {\n              array[index] = array[--index];\n            }\n            array[pos] = element;\n            return this;\n          },\n          search: function(element) {\n            var array = this.array, compare = this.compare, high = array.length - 1, low = 0, index, ordering;\n            while (high >= low) {\n              index = (high + low) / 2 >>> 0;\n              ordering = compare(array[index], element);\n              if (ordering < 0)\n                low = index + 1;\n              else if (ordering > 0)\n                high = index - 1;\n              else\n                return index;\n            }\n            return -1;\n          },\n          remove: function(element) {\n            var index = this.search(element);\n            if (index >= 0)\n              this.array.splice(index, 1);\n            return this;\n          }\n        });\n        SortedArray3.comparing = function(property, array) {\n          return new SortedArray3(array, function(a, b) {\n            return compareDefault(a[property], b[property]);\n          });\n        };\n        return SortedArray3;\n        function defclass(prototype) {\n          var constructor = prototype.constructor;\n          constructor.prototype = prototype;\n          return constructor;\n        }\n        function compareDefault(a, b) {\n          if (a < b)\n            return -1;\n          else if (a > b)\n            return 1;\n          else\n            return 0;\n        }\n      }();\n      if (typeof module === \"object\")\n        module.exports = SortedArray2;\n      if (typeof define === \"function\" && define.amd)\n        define(function() {\n          return SortedArray2;\n        });\n    }\n  });\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts\n  var src_exports = {};\n  __export(src_exports, {\n    Registry: () => Registry,\n    createObjectMatcher: () => createObjectMatcher\n  });\n  var import_sorted_array = __toESM(require_sorted_array());\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/dlv@1.1.3/node_modules/dlv/dist/dlv.es.js\n  function dlv_es_default(t, e, l, n, r) {\n    for (e = e.split ? e.split(\".\") : e, n = 0; n < e.length; n++)\n      t = t ? t[e[n]] : r;\n    return t === r ? l : t;\n  }\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts\n  function traverseObj(object, path = [], pairs = /* @__PURE__ */ new Map()) {\n    for (const key of Object.keys(object)) {\n      const val = object[key];\n      const nestedPath = [...path, key];\n      if (typeof val === \"object\") {\n        traverseObj(val, nestedPath, pairs);\n      } else {\n        pairs.set(nestedPath, val);\n      }\n    }\n    return pairs;\n  }\n  function createObjectMatcher(partialObj) {\n    const pairs = traverseObj(partialObj);\n    const matchFunction = (searchObj) => {\n      for (const entry of Array.from(pairs)) {\n        const [path, value] = entry;\n        if (dlv_es_default(searchObj, path) !== value) {\n          return false;\n        }\n      }\n      return true;\n    };\n    matchFunction.count = pairs.size;\n    return matchFunction;\n  }\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts\n  function createBasicMatcher(seed) {\n    const matcher = (match) => seed === match;\n    matcher.count = 1;\n    return matcher;\n  }\n  var createSortedArray = () => new import_sorted_array.default([], (c) => c.matcher.count);\n  var Registry = class {\n    constructor(initialSet) {\n      this.store = createSortedArray();\n      initialSet?.forEach(([match, value]) => {\n        this.set(match, value);\n      });\n    }\n    /** Add match -> value mapping to the registry */\n    set(match, value) {\n      const matcher = typeof match === \"object\" ? createObjectMatcher(match) : createBasicMatcher(match);\n      this.store.insert({\n        key: match,\n        value,\n        matcher\n      });\n    }\n    /** Fetch the best match in the registry */\n    get(query) {\n      for (const entry of this.store.array) {\n        if (entry.matcher(query)) {\n          return entry.value;\n        }\n      }\n    }\n    /** Loop over all entries and run callback */\n    forEach(callbackfn) {\n      for (const entry of this.store.array) {\n        callbackfn(entry);\n      }\n    }\n    /** Reset the items in the registry */\n    clear() {\n      this.store = createSortedArray();\n    }\n    /** Check if the registry is empty*/\n    isRegistryEmpty() {\n      return this.store.array.length === 0;\n    }\n  };\n  return __toCommonJS(src_exports);\n})();\n","export default function dlv(obj, key, def, p, undef) {\n\tkey = key.split ? key.split('.') : key;\n\tfor (p = 0; p < key.length; p++) {\n\t\tobj = obj ? obj[key[p]] : undef;\n\t}\n\treturn obj === undef ? def : obj;\n}\n","import dlv from \"dlv\";\n\n/** A function that checks overlapping properties against a reference value */\nexport type Matcher = ((searchObj: object) => boolean) & {\n  /** The count represents the specificity of this matcher */\n  count: number;\n};\n\n/** Traverse an object and collect any key/value pairs including nested keys */\nfunction traverseObj(\n  object: Record<any, any>,\n  path: string[] = [],\n  pairs: Map<string[], any> = new Map(),\n): Map<string[], any> {\n  for (const key of Object.keys(object)) {\n    const val: any = object[key];\n    const nestedPath = [...path, key];\n\n    if (typeof val === \"object\") {\n      traverseObj(val, nestedPath, pairs);\n    } else {\n      pairs.set(nestedPath, val);\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Given a partial object, create a matcher function that checks if another object matches the specified properties\n * @param partialObj The partial object to match against\n * @returns A matcher function that checks if an object matches the partial object\n */\nexport function createObjectMatcher(partialObj: object): Matcher {\n  // Convert the partial object into a list of [key, value] pairs;\n  const pairs = traverseObj(partialObj);\n\n  /** Generate a function to match against all of the properties we care about */\n  const matchFunction = (searchObj: object) => {\n    for (const entry of Array.from(pairs)) {\n      const [path, value] = entry;\n\n      if (dlv(searchObj, path) !== value) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  // Keep track of the specificity of the comparator\n  matchFunction.count = pairs.size;\n\n  return matchFunction;\n}\n","import SortedArray from \"sorted-array\";\nimport type { Matcher } from \"./deep-partial-matcher\";\nimport { createObjectMatcher } from \"./deep-partial-matcher\";\n\nexport { createObjectMatcher } from \"./deep-partial-matcher\";\n\n/** create a matcher function that matches exactly */\nfunction createBasicMatcher(seed: any): Matcher {\n  /** a simple matcher function that only matches itself */\n  const matcher = (match: any) => seed === match;\n  matcher.count = 1;\n\n  return matcher;\n}\n\ninterface RegistryIndex<V> {\n  /** The original object we wanted to match on  */\n  key: object;\n\n  /** The value to return */\n  value: V;\n\n  /** The matcher function for this entry */\n  matcher: Matcher;\n}\n\n/** create an empty sorted array using the matcher count */\nconst createSortedArray = <V>() =>\n  new SortedArray<RegistryIndex<V>>([], (c) => c.matcher.count);\n\n/**\n * A partial match registry is a map that uses an object to \"match\" against keys.\n * More specific matches take precedence over less specific ones.\n */\nexport class Registry<V> {\n  private store = createSortedArray<V>();\n\n  constructor(initialSet?: Array<[any, V]>) {\n    initialSet?.forEach(([match, value]) => {\n      this.set(match, value);\n    });\n  }\n\n  /** Add match -> value mapping to the registry */\n  set(match: any, value: V) {\n    const matcher =\n      typeof match === \"object\"\n        ? createObjectMatcher(match)\n        : createBasicMatcher(match);\n\n    this.store.insert({\n      key: match,\n      value,\n      matcher,\n    });\n  }\n\n  /** Fetch the best match in the registry */\n  get(query: any): V | undefined {\n    for (const entry of this.store.array) {\n      if (entry.matcher(query)) {\n        return entry.value;\n      }\n    }\n  }\n\n  /** Loop over all entries and run callback */\n  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {\n    for (const entry of this.store.array) {\n      callbackfn(entry);\n    }\n  }\n\n  /** Reset the items in the registry */\n  clear() {\n    this.store = createSortedArray<V>();\n  }\n\n  /** Check if the registry is empty*/\n  isRegistryEmpty() {\n    return this.store.array.length === 0;\n  }\n}\n","var SortedArray = (function () {\n    var SortedArray = defclass({\n\n        constructor: function (array, compare) {\n            this.array   = [];\n            this.compare = compare || compareDefault;\n            var length   = array.length,\n                index    = 0;\n            while (index < length) this.insert(array[index++]);\n        },\n        insert: function (element) {\n            var array   = this.array,\n                compare = this.compare,\n                high    = array.length-1,\n                low     = 0,\n                pos = -1,\n                index,\n                ordering;\n\n            // The array is sorted. You must find the position of new element in O(log(n)), not O(n).\n            while (high >= low) {\n                index    = (high + low) / 2 >>> 0;\n                ordering = compare(array[index], element);                \n                if (ordering < 0) low  = index + 1;\n                else if (ordering > 0) high = index - 1;\n                else {\n                    pos = index;\n                    break;\n                };\n            }\n\n            if (pos === -1) {\n                // if element was not found, high < low.\n                pos = high;\n            }\n            // This assures that equal elements inserted after will be in a higher position in array.\n            // They can be equal for comparison purposes, but different objects with different data.\n            // Respecting the chronological order can be important for many applications.\n            pos++;\n            high = array.length-1;\n            while ((pos < high) && (compare(element, array[pos]) === 0)){\n                pos++;\n            }\n            index = array.length;\n            // Just to increase array size.\n            array.push(element);            \n            // Much faster. No need to elements swap.\n            while (index > pos) {\n                array[index] = array[--index];\n            }\n            // Set the new element on its correct position.\n            array[pos] = element;\n\n            return this;\n        },\n        search: function (element) {\n            var array   = this.array,\n                compare = this.compare,\n                high    = array.length-1,\n                low     = 0,\n                // In most languages, inner variable declaration makes the code slower.\n                index,\n                ordering;\n\n            while (high >= low) {\n                index    = (high + low) / 2 >>> 0;\n                ordering = compare(array[index], element);\n\n                     if (ordering < 0) low  = index + 1;\n                else if (ordering > 0) high = index - 1;\n                else return index;\n            }\n\n            return -1;\n        },\n        remove: function (element) {\n            var index = this.search(element);\n            if (index >= 0) this.array.splice(index, 1);\n            return this;\n        }\n    });\n\n    SortedArray.comparing = function (property, array) {\n        return new SortedArray(array, function (a, b) {\n            // This should be faster than calling functions.\n            // Besides, this way it is not needed to create useless function to return property value.\n            return compareDefault(a[property], b[property]);\n        });\n    };\n\n    return SortedArray;\n\n    function defclass(prototype) {\n        var constructor = prototype.constructor;\n        constructor.prototype = prototype;\n        return constructor;\n    }\n\n    function compareDefault(a, b) {\n        // Equality has a very low chance to happen. It should be the last option.\n        if (a < b)\n            return -1;\n        else if (a > b)\n            return 1;\n        else\n            return 0;\n    }\n}());\n\nif (typeof module === \"object\") module.exports = SortedArray;\nif (typeof define === \"function\" && define.amd)\n    define(function () { return SortedArray; });\n"]}
+{"version":3,"sources":["/home/circleci/.cache/bazel/_bazel_circleci/e8362d362e14c7d23506d1dfa3aea8b8/sandbox/processwrapper-sandbox/2239/execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/dist/index.global.js","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/fast-sort@3.4.1/node_modules/fast-sort/dist/sort.mjs","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/dlv@1.1.3/node_modules/dlv/index.js","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts"],"names":["Registry","createNewSortInstance","opts","comparer","castComparer","arrayToSort","ctx","Array","isArray","inPlaceSorting","slice","asc","sortBy","sortArray","desc","by","dlv_es_default","obj","key","def","p","undef","split","length","createObjectMatcher","partialObj","pairs","traverseObj","matchFunction","searchObj","from","entry","path","value","count","size","createBasicMatcher","seed","matcher","match","__defProp","Object","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__hasOwnProp","prototype","hasOwnProperty","__export","target","all","name","get","enumerable","__copyProps","to","except","call","__toCommonJS","mod","src_exports","a","b","order","throwInvalidConfigErrorIfTrue","condition","context","Error","unpackObjectSorter","sortByObj","_a","multiPropertySorterProvider","defaultComparer","multiPropertySorter","sortByArr","depth","valA","valB","objectSorterConfig","equality","getSortStrategy","includes","multiPropSorter_1","sort","inPlaceSort","object","Map","keys","val","nestedPath","set","initialSet","logger","store","forEach","existingIndex","findIndex","splice","debug","push","query","callbackfn","clear","isRegistryEmpty"],"mappings":"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","sourcesContent":["\"use strict\";\nvar Registry = (() => {\n  var __defProp = Object.defineProperty;\n  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;\n  var __getOwnPropNames = Object.getOwnPropertyNames;\n  var __hasOwnProp = Object.prototype.hasOwnProperty;\n  var __export = (target, all) => {\n    for (var name in all)\n      __defProp(target, name, { get: all[name], enumerable: true });\n  };\n  var __copyProps = (to, from, except, desc) => {\n    if (from && typeof from === \"object\" || typeof from === \"function\") {\n      for (let key of __getOwnPropNames(from))\n        if (!__hasOwnProp.call(to, key) && key !== except)\n          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n    }\n    return to;\n  };\n  var __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts\n  var src_exports = {};\n  __export(src_exports, {\n    Registry: () => Registry,\n    createObjectMatcher: () => createObjectMatcher\n  });\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/fast-sort@3.4.1/node_modules/fast-sort/dist/sort.mjs\n  var castComparer = function(comparer) {\n    return function(a, b, order) {\n      return comparer(a, b, order) * order;\n    };\n  };\n  var throwInvalidConfigErrorIfTrue = function(condition, context) {\n    if (condition)\n      throw Error(\"Invalid sort config: \" + context);\n  };\n  var unpackObjectSorter = function(sortByObj) {\n    var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;\n    var order = asc ? 1 : -1;\n    var sortBy = asc || desc;\n    throwInvalidConfigErrorIfTrue(!sortBy, \"Expected `asc` or `desc` property\");\n    throwInvalidConfigErrorIfTrue(asc && desc, \"Ambiguous object with `asc` and `desc` config properties\");\n    var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);\n    return { order, sortBy, comparer };\n  };\n  var multiPropertySorterProvider = function(defaultComparer2) {\n    return function multiPropertySorter(sortBy, sortByArr, depth, order, comparer, a, b) {\n      var valA;\n      var valB;\n      if (typeof sortBy === \"string\") {\n        valA = a[sortBy];\n        valB = b[sortBy];\n      } else if (typeof sortBy === \"function\") {\n        valA = sortBy(a);\n        valB = sortBy(b);\n      } else {\n        var objectSorterConfig = unpackObjectSorter(sortBy);\n        return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer2, a, b);\n      }\n      var equality = comparer(valA, valB, order);\n      if ((equality === 0 || valA == null && valB == null) && sortByArr.length > depth) {\n        return multiPropertySorter(sortByArr[depth], sortByArr, depth + 1, order, comparer, a, b);\n      }\n      return equality;\n    };\n  };\n  function getSortStrategy(sortBy, comparer, order) {\n    if (sortBy === void 0 || sortBy === true) {\n      return function(a, b) {\n        return comparer(a, b, order);\n      };\n    }\n    if (typeof sortBy === \"string\") {\n      throwInvalidConfigErrorIfTrue(sortBy.includes(\".\"), \"String syntax not allowed for nested properties.\");\n      return function(a, b) {\n        return comparer(a[sortBy], b[sortBy], order);\n      };\n    }\n    if (typeof sortBy === \"function\") {\n      return function(a, b) {\n        return comparer(sortBy(a), sortBy(b), order);\n      };\n    }\n    if (Array.isArray(sortBy)) {\n      var multiPropSorter_1 = multiPropertySorterProvider(comparer);\n      return function(a, b) {\n        return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b);\n      };\n    }\n    var objectSorterConfig = unpackObjectSorter(sortBy);\n    return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);\n  }\n  var sortArray = function(order, ctx, sortBy, comparer) {\n    var _a;\n    if (!Array.isArray(ctx)) {\n      return ctx;\n    }\n    if (Array.isArray(sortBy) && sortBy.length < 2) {\n      _a = sortBy, sortBy = _a[0];\n    }\n    return ctx.sort(getSortStrategy(sortBy, comparer, order));\n  };\n  function createNewSortInstance(opts) {\n    var comparer = castComparer(opts.comparer);\n    return function(arrayToSort) {\n      var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting ? arrayToSort.slice() : arrayToSort;\n      return {\n        asc: function(sortBy) {\n          return sortArray(1, ctx, sortBy, comparer);\n        },\n        desc: function(sortBy) {\n          return sortArray(-1, ctx, sortBy, comparer);\n        },\n        by: function(sortBy) {\n          return sortArray(1, ctx, sortBy, comparer);\n        }\n      };\n    };\n  }\n  var defaultComparer = function(a, b, order) {\n    if (a == null)\n      return order;\n    if (b == null)\n      return -order;\n    if (typeof a !== typeof b) {\n      return typeof a < typeof b ? -1 : 1;\n    }\n    if (a < b)\n      return -1;\n    if (a > b)\n      return 1;\n    return 0;\n  };\n  var sort = createNewSortInstance({\n    comparer: defaultComparer\n  });\n  var inPlaceSort = createNewSortInstance({\n    comparer: defaultComparer,\n    inPlaceSorting: true\n  });\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/dlv@1.1.3/node_modules/dlv/dist/dlv.es.js\n  function dlv_es_default(t, e, l, n, r) {\n    for (e = e.split ? e.split(\".\") : e, n = 0; n < e.length; n++)\n      t = t ? t[e[n]] : r;\n    return t === r ? l : t;\n  }\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts\n  function traverseObj(object, path = [], pairs = /* @__PURE__ */ new Map()) {\n    for (const key of Object.keys(object)) {\n      const val = object[key];\n      const nestedPath = [...path, key];\n      if (typeof val === \"object\" && val !== null) {\n        traverseObj(val, nestedPath, pairs);\n      } else {\n        pairs.set(nestedPath, val);\n      }\n    }\n    return pairs;\n  }\n  function createObjectMatcher(partialObj) {\n    const pairs = traverseObj(partialObj);\n    const matchFunction = (searchObj) => {\n      for (const entry of Array.from(pairs)) {\n        const [path, value] = entry;\n        if (dlv_es_default(searchObj, path) !== value) {\n          return false;\n        }\n      }\n      return true;\n    };\n    matchFunction.count = pairs.size;\n    return matchFunction;\n  }\n\n  // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts\n  function createBasicMatcher(seed) {\n    const matcher = (match) => seed === match;\n    matcher.count = 1;\n    return matcher;\n  }\n  var Registry = class {\n    /**\n     * Creates a new Registry instance\n     *\n     * @param initialSet - Optional array of [key, value] tuples to populate the registry\n     * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)\n     */\n    constructor(initialSet, logger) {\n      this.store = [];\n      this.logger = logger;\n      initialSet?.forEach(([match, value]) => {\n        this.set(match, value);\n      });\n    }\n    /**\n     * Add match -> value mapping to the registry\n     *\n     * If an entry with the same specificity and matching key already exists, it will be replaced\n     * and a debug log will be emitted (if a logger is configured).\n     *\n     * @param match - The key to match against (can be a primitive or object)\n     * @param value - The value to associate with this key\n     */\n    set(match, value) {\n      const matcher = typeof match === \"object\" ? createObjectMatcher(match) : createBasicMatcher(match);\n      const existingIndex = this.store.findIndex(\n        (entry) => entry.matcher(match) && matcher(entry.key)\n      );\n      if (existingIndex !== -1) {\n        this.store.splice(existingIndex, 1);\n        this.logger?.debug?.(\n          \"Registry: Replacing existing entry for key \",\n          match\n        );\n      }\n      this.store.push({\n        key: match,\n        value,\n        matcher\n      });\n      this.store = sort(this.store).desc((entry) => entry.matcher.count);\n    }\n    /**\n     * Fetch the best match in the registry\n     *\n     * Searches for the most specific entry that matches the given query.\n     * The registry is sorted by specificity (matcher.count) in descending order,\n     * so we iterate forward to find the highest specificity match first.\n     *\n     * @param query - The query object to match against registered keys\n     * @returns The value associated with the best matching key, or undefined if no match found\n     */\n    get(query) {\n      for (const entry of this.store) {\n        if (entry.matcher(query)) {\n          return entry.value;\n        }\n      }\n      return void 0;\n    }\n    /** Loop over all entries and run callback */\n    forEach(callbackfn) {\n      for (const entry of this.store) {\n        callbackfn(entry);\n      }\n    }\n    /** Reset the items in the registry */\n    clear() {\n      this.store = [];\n    }\n    /** Check if the registry is empty*/\n    isRegistryEmpty() {\n      return this.store.length === 0;\n    }\n  };\n  return __toCommonJS(src_exports);\n})();\n","// >>> INTERFACES <<<\r\n// >>> HELPERS <<<\r\nvar castComparer = function (comparer) { return function (a, b, order) { return comparer(a, b, order) * order; }; };\r\nvar throwInvalidConfigErrorIfTrue = function (condition, context) {\r\n    if (condition)\r\n        throw Error(\"Invalid sort config: \" + context);\r\n};\r\nvar unpackObjectSorter = function (sortByObj) {\r\n    var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;\r\n    var order = asc ? 1 : -1;\r\n    var sortBy = (asc || desc);\r\n    // Validate object config\r\n    throwInvalidConfigErrorIfTrue(!sortBy, 'Expected `asc` or `desc` property');\r\n    throwInvalidConfigErrorIfTrue(asc && desc, 'Ambiguous object with `asc` and `desc` config properties');\r\n    var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);\r\n    return { order: order, sortBy: sortBy, comparer: comparer };\r\n};\r\n// >>> SORTERS <<<\r\nvar multiPropertySorterProvider = function (defaultComparer) {\r\n    return function multiPropertySorter(sortBy, sortByArr, depth, order, comparer, a, b) {\r\n        var valA;\r\n        var valB;\r\n        if (typeof sortBy === 'string') {\r\n            valA = a[sortBy];\r\n            valB = b[sortBy];\r\n        }\r\n        else if (typeof sortBy === 'function') {\r\n            valA = sortBy(a);\r\n            valB = sortBy(b);\r\n        }\r\n        else {\r\n            var objectSorterConfig = unpackObjectSorter(sortBy);\r\n            return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer, a, b);\r\n        }\r\n        var equality = comparer(valA, valB, order);\r\n        if ((equality === 0 || (valA == null && valB == null)) &&\r\n            sortByArr.length > depth) {\r\n            return multiPropertySorter(sortByArr[depth], sortByArr, depth + 1, order, comparer, a, b);\r\n        }\r\n        return equality;\r\n    };\r\n};\r\nfunction getSortStrategy(sortBy, comparer, order) {\r\n    // Flat array sorter\r\n    if (sortBy === undefined || sortBy === true) {\r\n        return function (a, b) { return comparer(a, b, order); };\r\n    }\r\n    // Sort list of objects by single object key\r\n    if (typeof sortBy === 'string') {\r\n        throwInvalidConfigErrorIfTrue(sortBy.includes('.'), 'String syntax not allowed for nested properties.');\r\n        return function (a, b) { return comparer(a[sortBy], b[sortBy], order); };\r\n    }\r\n    // Sort list of objects by single function sorter\r\n    if (typeof sortBy === 'function') {\r\n        return function (a, b) { return comparer(sortBy(a), sortBy(b), order); };\r\n    }\r\n    // Sort by multiple properties\r\n    if (Array.isArray(sortBy)) {\r\n        var multiPropSorter_1 = multiPropertySorterProvider(comparer);\r\n        return function (a, b) { return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b); };\r\n    }\r\n    // Unpack object config to get actual sorter strategy\r\n    var objectSorterConfig = unpackObjectSorter(sortBy);\r\n    return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);\r\n}\r\nvar sortArray = function (order, ctx, sortBy, comparer) {\r\n    var _a;\r\n    if (!Array.isArray(ctx)) {\r\n        return ctx;\r\n    }\r\n    // Unwrap sortBy if array with only 1 value to get faster sort strategy\r\n    if (Array.isArray(sortBy) && sortBy.length < 2) {\r\n        _a = sortBy, sortBy = _a[0];\r\n    }\r\n    return ctx.sort(getSortStrategy(sortBy, comparer, order));\r\n};\r\nfunction createNewSortInstance(opts) {\r\n    var comparer = castComparer(opts.comparer);\r\n    return function (arrayToSort) {\r\n        var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting\r\n            ? arrayToSort.slice()\r\n            : arrayToSort;\r\n        return {\r\n            asc: function (sortBy) {\r\n                return sortArray(1, ctx, sortBy, comparer);\r\n            },\r\n            desc: function (sortBy) {\r\n                return sortArray(-1, ctx, sortBy, comparer);\r\n            },\r\n            by: function (sortBy) {\r\n                return sortArray(1, ctx, sortBy, comparer);\r\n            },\r\n        };\r\n    };\r\n}\r\nvar defaultComparer = function (a, b, order) {\r\n    if (a == null)\r\n        return order;\r\n    if (b == null)\r\n        return -order;\r\n    if (typeof a !== typeof b) {\r\n        return typeof a < typeof b ? -1 : 1;\r\n    }\r\n    if (a < b)\r\n        return -1;\r\n    if (a > b)\r\n        return 1;\r\n    return 0;\r\n};\r\nvar sort = createNewSortInstance({\r\n    comparer: defaultComparer,\r\n});\r\nvar inPlaceSort = createNewSortInstance({\r\n    comparer: defaultComparer,\r\n    inPlaceSorting: true,\r\n});\n\nexport { createNewSortInstance, defaultComparer, inPlaceSort, sort };\n","export default function dlv(obj, key, def, p, undef) {\n\tkey = key.split ? key.split('.') : key;\n\tfor (p = 0; p < key.length; p++) {\n\t\tobj = obj ? obj[key[p]] : undef;\n\t}\n\treturn obj === undef ? def : obj;\n}\n","import dlv from \"dlv\";\n\n/** A function that checks overlapping properties against a reference value */\nexport type Matcher = ((searchObj: object) => boolean) & {\n  /** The count represents the specificity of this matcher */\n  count: number;\n};\n\n/** Traverse an object and collect any key/value pairs including nested keys */\nfunction traverseObj(\n  object: Record<any, any>,\n  path: string[] = [],\n  pairs: Map<string[], any> = new Map(),\n): Map<string[], any> {\n  for (const key of Object.keys(object)) {\n    const val: any = object[key];\n    const nestedPath = [...path, key];\n\n    /* Explicitly avoid traversing null values.\n    JavaScript's typeof null === \"object\" would otherwise cause the function to traverse null as an object\n    and throw an error. \n    \n    Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null\n    */\n    if (typeof val === \"object\" && val !== null) {\n      traverseObj(val, nestedPath, pairs);\n    } else {\n      pairs.set(nestedPath, val);\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Given a partial object, create a matcher function that checks if another object matches the specified properties\n * @param partialObj The partial object to match against\n * @returns A matcher function that checks if an object matches the partial object\n */\nexport function createObjectMatcher(partialObj: object): Matcher {\n  // Convert the partial object into a list of [key, value] pairs;\n  const pairs = traverseObj(partialObj);\n\n  /** Generate a function to match against all of the properties we care about */\n  const matchFunction = (searchObj: object) => {\n    for (const entry of Array.from(pairs)) {\n      const [path, value] = entry;\n\n      if (dlv(searchObj, path) !== value) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  // Keep track of the specificity of the comparator\n  matchFunction.count = pairs.size;\n\n  return matchFunction;\n}\n","import { sort } from \"fast-sort\";\nimport type { Matcher } from \"./deep-partial-matcher\";\nimport { createObjectMatcher } from \"./deep-partial-matcher\";\n\nexport { createObjectMatcher } from \"./deep-partial-matcher\";\n\n/** Minimal logger interface for registry operations */\ninterface Logger {\n  debug?: (...args: Array<any>) => void;\n}\n\n/** create a matcher function that matches exactly */\nfunction createBasicMatcher(seed: any): Matcher {\n  /** a simple matcher function that only matches itself */\n  const matcher = (match: any) => seed === match;\n  matcher.count = 1;\n\n  return matcher;\n}\n\ninterface RegistryIndex<V> {\n  /** The original object we wanted to match on  */\n  key: object;\n\n  /** The value to return */\n  value: V;\n\n  /** The matcher function for this entry */\n  matcher: Matcher;\n}\n\n/**\n * A partial match registry is a map that uses an object to \"match\" against keys.\n * More specific matches take precedence over less specific ones.\n */\nexport class Registry<V> {\n  private store: Array<RegistryIndex<V>> = [];\n  private logger?: Logger;\n\n  /**\n   * Creates a new Registry instance\n   *\n   * @param initialSet - Optional array of [key, value] tuples to populate the registry\n   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)\n   */\n  constructor(initialSet?: Array<[any, V]>, logger?: Logger) {\n    this.logger = logger;\n    initialSet?.forEach(([match, value]) => {\n      this.set(match, value);\n    });\n  }\n\n  /**\n   * Add match -> value mapping to the registry\n   *\n   * If an entry with the same specificity and matching key already exists, it will be replaced\n   * and a debug log will be emitted (if a logger is configured).\n   *\n   * @param match - The key to match against (can be a primitive or object)\n   * @param value - The value to associate with this key\n   */\n  set(match: any, value: V): void {\n    const matcher =\n      typeof match === \"object\"\n        ? createObjectMatcher(match)\n        : createBasicMatcher(match);\n\n    // Find and remove any existing entry that matches this key\n    // Use matcher to check for matching keys (handles deep equality)\n    const existingIndex = this.store.findIndex(\n      (entry) => entry.matcher(match) && matcher(entry.key),\n    );\n    if (existingIndex !== -1) {\n      this.store.splice(existingIndex, 1);\n      this.logger?.debug?.(\n        \"Registry: Replacing existing entry for key \",\n        match,\n      );\n    }\n\n    this.store.push({\n      key: match,\n      value,\n      matcher,\n    });\n\n    // Sort in descending order by matcher.count (highest specificity first)\n    this.store = sort(this.store).desc((entry) => entry.matcher.count);\n  }\n\n  /**\n   * Fetch the best match in the registry\n   *\n   * Searches for the most specific entry that matches the given query.\n   * The registry is sorted by specificity (matcher.count) in descending order,\n   * so we iterate forward to find the highest specificity match first.\n   *\n   * @param query - The query object to match against registered keys\n   * @returns The value associated with the best matching key, or undefined if no match found\n   */\n  get(query: any): V | undefined {\n    // Store is sorted by matcher.count (descending), so iterate forward\n    for (const entry of this.store) {\n      if (entry.matcher(query)) {\n        return entry.value;\n      }\n    }\n    return undefined;\n  }\n\n  /** Loop over all entries and run callback */\n  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {\n    for (const entry of this.store) {\n      callbackfn(entry);\n    }\n  }\n\n  /** Reset the items in the registry */\n  clear(): void {\n    this.store = [];\n  }\n\n  /** Check if the registry is empty*/\n  isRegistryEmpty(): boolean {\n    return this.store.length === 0;\n  }\n}\n"]}

package/dist/cjs/index.cjs

@@ -34,7 +34,7 @@ __export(src_exports, {
   createObjectMatcher: () => createObjectMatcher
 });
 module.exports = __toCommonJS(src_exports);
-var import_sorted_array = __toESM(require("sorted-array"));
+var import_fast_sort = require("fast-sort");
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts
 var import_dlv = __toESM(require("dlv"));
@@ -42,7 +42,7 @@ function traverseObj(object, path = [], pairs = /* @__PURE__ */ new Map()) {
   for (const key of Object.keys(object)) {
     const val = object[key];
     const nestedPath = [...path, key];
-    if (typeof val === "object") {
+    if (typeof val === "object" && val !== null) {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);
@@ -71,44 +71,79 @@ function createBasicMatcher(seed) {
   matcher.count = 1;
   return matcher;
 }
-var createSortedArray = () => new import_sorted_array.default([], (c) => c.matcher.count);
 var Registry = class {
-  constructor(initialSet) {
-    this.store = createSortedArray();
+  /**
+   * Creates a new Registry instance
+   *
+   * @param initialSet - Optional array of [key, value] tuples to populate the registry
+   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)
+   */
+  constructor(initialSet, logger) {
+    this.store = [];
+    this.logger = logger;
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
-  /** Add match -> value mapping to the registry */
+  /**
+   * Add match -> value mapping to the registry
+   *
+   * If an entry with the same specificity and matching key already exists, it will be replaced
+   * and a debug log will be emitted (if a logger is configured).
+   *
+   * @param match - The key to match against (can be a primitive or object)
+   * @param value - The value to associate with this key
+   */
   set(match, value) {
     const matcher = typeof match === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-    this.store.insert({
+    const existingIndex = this.store.findIndex(
+      (entry) => entry.matcher(match) && matcher(entry.key)
+    );
+    if (existingIndex !== -1) {
+      this.store.splice(existingIndex, 1);
+      this.logger?.debug?.(
+        "Registry: Replacing existing entry for key ",
+        match
+      );
+    }
+    this.store.push({
       key: match,
       value,
       matcher
     });
+    this.store = (0, import_fast_sort.sort)(this.store).desc((entry) => entry.matcher.count);
   }
-  /** Fetch the best match in the registry */
+  /**
+   * Fetch the best match in the registry
+   *
+   * Searches for the most specific entry that matches the given query.
+   * The registry is sorted by specificity (matcher.count) in descending order,
+   * so we iterate forward to find the highest specificity match first.
+   *
+   * @param query - The query object to match against registered keys
+   * @returns The value associated with the best matching key, or undefined if no match found
+   */
   get(query) {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       if (entry.matcher(query)) {
         return entry.value;
       }
     }
+    return void 0;
   }
   /** Loop over all entries and run callback */
   forEach(callbackfn) {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       callbackfn(entry);
     }
   }
   /** Reset the items in the registry */
   clear() {
-    this.store = createSortedArray();
+    this.store = [];
   }
   /** Check if the registry is empty*/
   isRegistryEmpty() {
-    return this.store.array.length === 0;
+    return this.store.length === 0;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts","../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts"],"sourcesContent":["import SortedArray from \"sorted-array\";\nimport type { Matcher } from \"./deep-partial-matcher\";\nimport { createObjectMatcher } from \"./deep-partial-matcher\";\n\nexport { createObjectMatcher } from \"./deep-partial-matcher\";\n\n/** create a matcher function that matches exactly */\nfunction createBasicMatcher(seed: any): Matcher {\n  /** a simple matcher function that only matches itself */\n  const matcher = (match: any) => seed === match;\n  matcher.count = 1;\n\n  return matcher;\n}\n\ninterface RegistryIndex<V> {\n  /** The original object we wanted to match on  */\n  key: object;\n\n  /** The value to return */\n  value: V;\n\n  /** The matcher function for this entry */\n  matcher: Matcher;\n}\n\n/** create an empty sorted array using the matcher count */\nconst createSortedArray = <V>() =>\n  new SortedArray<RegistryIndex<V>>([], (c) => c.matcher.count);\n\n/**\n * A partial match registry is a map that uses an object to \"match\" against keys.\n * More specific matches take precedence over less specific ones.\n */\nexport class Registry<V> {\n  private store = createSortedArray<V>();\n\n  constructor(initialSet?: Array<[any, V]>) {\n    initialSet?.forEach(([match, value]) => {\n      this.set(match, value);\n    });\n  }\n\n  /** Add match -> value mapping to the registry */\n  set(match: any, value: V) {\n    const matcher =\n      typeof match === \"object\"\n        ? createObjectMatcher(match)\n        : createBasicMatcher(match);\n\n    this.store.insert({\n      key: match,\n      value,\n      matcher,\n    });\n  }\n\n  /** Fetch the best match in the registry */\n  get(query: any): V | undefined {\n    for (const entry of this.store.array) {\n      if (entry.matcher(query)) {\n        return entry.value;\n      }\n    }\n  }\n\n  /** Loop over all entries and run callback */\n  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {\n    for (const entry of this.store.array) {\n      callbackfn(entry);\n    }\n  }\n\n  /** Reset the items in the registry */\n  clear() {\n    this.store = createSortedArray<V>();\n  }\n\n  /** Check if the registry is empty*/\n  isRegistryEmpty() {\n    return this.store.array.length === 0;\n  }\n}\n","import dlv from \"dlv\";\n\n/** A function that checks overlapping properties against a reference value */\nexport type Matcher = ((searchObj: object) => boolean) & {\n  /** The count represents the specificity of this matcher */\n  count: number;\n};\n\n/** Traverse an object and collect any key/value pairs including nested keys */\nfunction traverseObj(\n  object: Record<any, any>,\n  path: string[] = [],\n  pairs: Map<string[], any> = new Map(),\n): Map<string[], any> {\n  for (const key of Object.keys(object)) {\n    const val: any = object[key];\n    const nestedPath = [...path, key];\n\n    if (typeof val === \"object\") {\n      traverseObj(val, nestedPath, pairs);\n    } else {\n      pairs.set(nestedPath, val);\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Given a partial object, create a matcher function that checks if another object matches the specified properties\n * @param partialObj The partial object to match against\n * @returns A matcher function that checks if an object matches the partial object\n */\nexport function createObjectMatcher(partialObj: object): Matcher {\n  // Convert the partial object into a list of [key, value] pairs;\n  const pairs = traverseObj(partialObj);\n\n  /** Generate a function to match against all of the properties we care about */\n  const matchFunction = (searchObj: object) => {\n    for (const entry of Array.from(pairs)) {\n      const [path, value] = entry;\n\n      if (dlv(searchObj, path) !== value) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  // Keep track of the specificity of the comparator\n  matchFunction.count = pairs.size;\n\n  return matchFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAAwB;;;ACAxB,iBAAgB;AAShB,SAAS,YACP,QACA,OAAiB,CAAC,GAClB,QAA4B,oBAAI,IAAI,GAChB;AACpB,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,UAAM,MAAW,OAAO,GAAG;AAC3B,UAAM,aAAa,CAAC,GAAG,MAAM,GAAG;AAEhC,QAAI,OAAO,QAAQ,UAAU;AAC3B,kBAAY,KAAK,YAAY,KAAK;AAAA,IACpC,OAAO;AACL,YAAM,IAAI,YAAY,GAAG;AAAA,IAC3B;AAAA,EACF;AAEA,SAAO;AACT;AAOO,SAAS,oBAAoB,YAA6B;AAE/D,QAAM,QAAQ,YAAY,UAAU;AAGpC,QAAM,gBAAgB,CAAC,cAAsB;AAC3C,eAAW,SAAS,MAAM,KAAK,KAAK,GAAG;AACrC,YAAM,CAAC,MAAM,KAAK,IAAI;AAEtB,cAAI,WAAAA,SAAI,WAAW,IAAI,MAAM,OAAO;AAClC,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAGA,gBAAc,QAAQ,MAAM;AAE5B,SAAO;AACT;;;AD/CA,SAAS,mBAAmB,MAAoB;AAE9C,QAAM,UAAU,CAAC,UAAe,SAAS;AACzC,UAAQ,QAAQ;AAEhB,SAAO;AACT;AAcA,IAAM,oBAAoB,MACxB,IAAI,oBAAAC,QAA8B,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,KAAK;AAMvD,IAAM,WAAN,MAAkB;AAAA,EAGvB,YAAY,YAA8B;AAF1C,SAAQ,QAAQ,kBAAqB;AAGnC,gBAAY,QAAQ,CAAC,CAAC,OAAO,KAAK,MAAM;AACtC,WAAK,IAAI,OAAO,KAAK;AAAA,IACvB,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,IAAI,OAAY,OAAU;AACxB,UAAM,UACJ,OAAO,UAAU,WACb,oBAAoB,KAAK,IACzB,mBAAmB,KAAK;AAE9B,SAAK,MAAM,OAAO;AAAA,MAChB,KAAK;AAAA,MACL;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,IAAI,OAA2B;AAC7B,eAAW,SAAS,KAAK,MAAM,OAAO;AACpC,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ,YAAqD;AAC3D,eAAW,SAAS,KAAK,MAAM,OAAO;AACpC,iBAAW,KAAK;AAAA,IAClB;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ;AACN,SAAK,QAAQ,kBAAqB;AAAA,EACpC;AAAA;AAAA,EAGA,kBAAkB;AAChB,WAAO,KAAK,MAAM,MAAM,WAAW;AAAA,EACrC;AACF;","names":["dlv","SortedArray"]}
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts","../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts"],"sourcesContent":["import { sort } from \"fast-sort\";\nimport type { Matcher } from \"./deep-partial-matcher\";\nimport { createObjectMatcher } from \"./deep-partial-matcher\";\n\nexport { createObjectMatcher } from \"./deep-partial-matcher\";\n\n/** Minimal logger interface for registry operations */\ninterface Logger {\n  debug?: (...args: Array<any>) => void;\n}\n\n/** create a matcher function that matches exactly */\nfunction createBasicMatcher(seed: any): Matcher {\n  /** a simple matcher function that only matches itself */\n  const matcher = (match: any) => seed === match;\n  matcher.count = 1;\n\n  return matcher;\n}\n\ninterface RegistryIndex<V> {\n  /** The original object we wanted to match on  */\n  key: object;\n\n  /** The value to return */\n  value: V;\n\n  /** The matcher function for this entry */\n  matcher: Matcher;\n}\n\n/**\n * A partial match registry is a map that uses an object to \"match\" against keys.\n * More specific matches take precedence over less specific ones.\n */\nexport class Registry<V> {\n  private store: Array<RegistryIndex<V>> = [];\n  private logger?: Logger;\n\n  /**\n   * Creates a new Registry instance\n   *\n   * @param initialSet - Optional array of [key, value] tuples to populate the registry\n   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)\n   */\n  constructor(initialSet?: Array<[any, V]>, logger?: Logger) {\n    this.logger = logger;\n    initialSet?.forEach(([match, value]) => {\n      this.set(match, value);\n    });\n  }\n\n  /**\n   * Add match -> value mapping to the registry\n   *\n   * If an entry with the same specificity and matching key already exists, it will be replaced\n   * and a debug log will be emitted (if a logger is configured).\n   *\n   * @param match - The key to match against (can be a primitive or object)\n   * @param value - The value to associate with this key\n   */\n  set(match: any, value: V): void {\n    const matcher =\n      typeof match === \"object\"\n        ? createObjectMatcher(match)\n        : createBasicMatcher(match);\n\n    // Find and remove any existing entry that matches this key\n    // Use matcher to check for matching keys (handles deep equality)\n    const existingIndex = this.store.findIndex(\n      (entry) => entry.matcher(match) && matcher(entry.key),\n    );\n    if (existingIndex !== -1) {\n      this.store.splice(existingIndex, 1);\n      this.logger?.debug?.(\n        \"Registry: Replacing existing entry for key \",\n        match,\n      );\n    }\n\n    this.store.push({\n      key: match,\n      value,\n      matcher,\n    });\n\n    // Sort in descending order by matcher.count (highest specificity first)\n    this.store = sort(this.store).desc((entry) => entry.matcher.count);\n  }\n\n  /**\n   * Fetch the best match in the registry\n   *\n   * Searches for the most specific entry that matches the given query.\n   * The registry is sorted by specificity (matcher.count) in descending order,\n   * so we iterate forward to find the highest specificity match first.\n   *\n   * @param query - The query object to match against registered keys\n   * @returns The value associated with the best matching key, or undefined if no match found\n   */\n  get(query: any): V | undefined {\n    // Store is sorted by matcher.count (descending), so iterate forward\n    for (const entry of this.store) {\n      if (entry.matcher(query)) {\n        return entry.value;\n      }\n    }\n    return undefined;\n  }\n\n  /** Loop over all entries and run callback */\n  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {\n    for (const entry of this.store) {\n      callbackfn(entry);\n    }\n  }\n\n  /** Reset the items in the registry */\n  clear(): void {\n    this.store = [];\n  }\n\n  /** Check if the registry is empty*/\n  isRegistryEmpty(): boolean {\n    return this.store.length === 0;\n  }\n}\n","import dlv from \"dlv\";\n\n/** A function that checks overlapping properties against a reference value */\nexport type Matcher = ((searchObj: object) => boolean) & {\n  /** The count represents the specificity of this matcher */\n  count: number;\n};\n\n/** Traverse an object and collect any key/value pairs including nested keys */\nfunction traverseObj(\n  object: Record<any, any>,\n  path: string[] = [],\n  pairs: Map<string[], any> = new Map(),\n): Map<string[], any> {\n  for (const key of Object.keys(object)) {\n    const val: any = object[key];\n    const nestedPath = [...path, key];\n\n    /* Explicitly avoid traversing null values.\n    JavaScript's typeof null === \"object\" would otherwise cause the function to traverse null as an object\n    and throw an error. \n    \n    Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null\n    */\n    if (typeof val === \"object\" && val !== null) {\n      traverseObj(val, nestedPath, pairs);\n    } else {\n      pairs.set(nestedPath, val);\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Given a partial object, create a matcher function that checks if another object matches the specified properties\n * @param partialObj The partial object to match against\n * @returns A matcher function that checks if an object matches the partial object\n */\nexport function createObjectMatcher(partialObj: object): Matcher {\n  // Convert the partial object into a list of [key, value] pairs;\n  const pairs = traverseObj(partialObj);\n\n  /** Generate a function to match against all of the properties we care about */\n  const matchFunction = (searchObj: object) => {\n    for (const entry of Array.from(pairs)) {\n      const [path, value] = entry;\n\n      if (dlv(searchObj, path) !== value) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  // Keep track of the specificity of the comparator\n  matchFunction.count = pairs.size;\n\n  return matchFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAqB;;;ACArB,iBAAgB;AAShB,SAAS,YACP,QACA,OAAiB,CAAC,GAClB,QAA4B,oBAAI,IAAI,GAChB;AACpB,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,UAAM,MAAW,OAAO,GAAG;AAC3B,UAAM,aAAa,CAAC,GAAG,MAAM,GAAG;AAQhC,QAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,kBAAY,KAAK,YAAY,KAAK;AAAA,IACpC,OAAO;AACL,YAAM,IAAI,YAAY,GAAG;AAAA,IAC3B;AAAA,EACF;AAEA,SAAO;AACT;AAOO,SAAS,oBAAoB,YAA6B;AAE/D,QAAM,QAAQ,YAAY,UAAU;AAGpC,QAAM,gBAAgB,CAAC,cAAsB;AAC3C,eAAW,SAAS,MAAM,KAAK,KAAK,GAAG;AACrC,YAAM,CAAC,MAAM,KAAK,IAAI;AAEtB,cAAI,WAAAA,SAAI,WAAW,IAAI,MAAM,OAAO;AAClC,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAGA,gBAAc,QAAQ,MAAM;AAE5B,SAAO;AACT;;;ADhDA,SAAS,mBAAmB,MAAoB;AAE9C,QAAM,UAAU,CAAC,UAAe,SAAS;AACzC,UAAQ,QAAQ;AAEhB,SAAO;AACT;AAiBO,IAAM,WAAN,MAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUvB,YAAY,YAA8B,QAAiB;AAT3D,SAAQ,QAAiC,CAAC;AAUxC,SAAK,SAAS;AACd,gBAAY,QAAQ,CAAC,CAAC,OAAO,KAAK,MAAM;AACtC,WAAK,IAAI,OAAO,KAAK;AAAA,IACvB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,IAAI,OAAY,OAAgB;AAC9B,UAAM,UACJ,OAAO,UAAU,WACb,oBAAoB,KAAK,IACzB,mBAAmB,KAAK;AAI9B,UAAM,gBAAgB,KAAK,MAAM;AAAA,MAC/B,CAAC,UAAU,MAAM,QAAQ,KAAK,KAAK,QAAQ,MAAM,GAAG;AAAA,IACtD;AACA,QAAI,kBAAkB,IAAI;AACxB,WAAK,MAAM,OAAO,eAAe,CAAC;AAClC,WAAK,QAAQ;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,SAAK,MAAM,KAAK;AAAA,MACd,KAAK;AAAA,MACL;AAAA,MACA;AAAA,IACF,CAAC;AAGD,SAAK,YAAQ,uBAAK,KAAK,KAAK,EAAE,KAAK,CAAC,UAAU,MAAM,QAAQ,KAAK;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,IAAI,OAA2B;AAE7B,eAAW,SAAS,KAAK,OAAO;AAC9B,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,MAAM;AAAA,MACf;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAQ,YAAqD;AAC3D,eAAW,SAAS,KAAK,OAAO;AAC9B,iBAAW,KAAK;AAAA,IAClB;AAAA,EACF;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,QAAQ,CAAC;AAAA,EAChB;AAAA;AAAA,EAGA,kBAA2B;AACzB,WAAO,KAAK,MAAM,WAAW;AAAA,EAC/B;AACF;","names":["dlv"]}

package/dist/index.legacy-esm.js

@@ -1,5 +1,5 @@
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts
-import SortedArray from "sorted-array";
+import { sort } from "fast-sort";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts
 import dlv from "dlv";
@@ -7,7 +7,7 @@ function traverseObj(object, path = [], pairs = /* @__PURE__ */ new Map()) {
   for (const key of Object.keys(object)) {
     const val = object[key];
     const nestedPath = [...path, key];
-    if (typeof val === "object") {
+    if (typeof val === "object" && val !== null) {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);
@@ -36,44 +36,79 @@ function createBasicMatcher(seed) {
   matcher.count = 1;
   return matcher;
 }
-var createSortedArray = () => new SortedArray([], (c) => c.matcher.count);
 var Registry = class {
-  constructor(initialSet) {
-    this.store = createSortedArray();
+  /**
+   * Creates a new Registry instance
+   *
+   * @param initialSet - Optional array of [key, value] tuples to populate the registry
+   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)
+   */
+  constructor(initialSet, logger) {
+    this.store = [];
+    this.logger = logger;
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
-  /** Add match -> value mapping to the registry */
+  /**
+   * Add match -> value mapping to the registry
+   *
+   * If an entry with the same specificity and matching key already exists, it will be replaced
+   * and a debug log will be emitted (if a logger is configured).
+   *
+   * @param match - The key to match against (can be a primitive or object)
+   * @param value - The value to associate with this key
+   */
   set(match, value) {
     const matcher = typeof match === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-    this.store.insert({
+    const existingIndex = this.store.findIndex(
+      (entry) => entry.matcher(match) && matcher(entry.key)
+    );
+    if (existingIndex !== -1) {
+      this.store.splice(existingIndex, 1);
+      this.logger?.debug?.(
+        "Registry: Replacing existing entry for key ",
+        match
+      );
+    }
+    this.store.push({
       key: match,
       value,
       matcher
     });
+    this.store = sort(this.store).desc((entry) => entry.matcher.count);
   }
-  /** Fetch the best match in the registry */
+  /**
+   * Fetch the best match in the registry
+   *
+   * Searches for the most specific entry that matches the given query.
+   * The registry is sorted by specificity (matcher.count) in descending order,
+   * so we iterate forward to find the highest specificity match first.
+   *
+   * @param query - The query object to match against registered keys
+   * @returns The value associated with the best matching key, or undefined if no match found
+   */
   get(query) {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       if (entry.matcher(query)) {
         return entry.value;
       }
     }
+    return void 0;
   }
   /** Loop over all entries and run callback */
   forEach(callbackfn) {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       callbackfn(entry);
     }
   }
   /** Reset the items in the registry */
   clear() {
-    this.store = createSortedArray();
+    this.store = [];
   }
   /** Check if the registry is empty*/
   isRegistryEmpty() {
-    return this.store.array.length === 0;
+    return this.store.length === 0;
   }
 };
 export {

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts
-import SortedArray from "sorted-array";
+import { sort } from "fast-sort";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts
 import dlv from "dlv";
@@ -7,7 +7,7 @@ function traverseObj(object, path = [], pairs = /* @__PURE__ */ new Map()) {
   for (const key of Object.keys(object)) {
     const val = object[key];
     const nestedPath = [...path, key];
-    if (typeof val === "object") {
+    if (typeof val === "object" && val !== null) {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);
@@ -36,44 +36,79 @@ function createBasicMatcher(seed) {
   matcher.count = 1;
   return matcher;
 }
-var createSortedArray = () => new SortedArray([], (c) => c.matcher.count);
 var Registry = class {
-  constructor(initialSet) {
-    this.store = createSortedArray();
+  /**
+   * Creates a new Registry instance
+   *
+   * @param initialSet - Optional array of [key, value] tuples to populate the registry
+   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)
+   */
+  constructor(initialSet, logger) {
+    this.store = [];
+    this.logger = logger;
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
-  /** Add match -> value mapping to the registry */
+  /**
+   * Add match -> value mapping to the registry
+   *
+   * If an entry with the same specificity and matching key already exists, it will be replaced
+   * and a debug log will be emitted (if a logger is configured).
+   *
+   * @param match - The key to match against (can be a primitive or object)
+   * @param value - The value to associate with this key
+   */
   set(match, value) {
     const matcher = typeof match === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-    this.store.insert({
+    const existingIndex = this.store.findIndex(
+      (entry) => entry.matcher(match) && matcher(entry.key)
+    );
+    if (existingIndex !== -1) {
+      this.store.splice(existingIndex, 1);
+      this.logger?.debug?.(
+        "Registry: Replacing existing entry for key ",
+        match
+      );
+    }
+    this.store.push({
       key: match,
       value,
       matcher
     });
+    this.store = sort(this.store).desc((entry) => entry.matcher.count);
   }
-  /** Fetch the best match in the registry */
+  /**
+   * Fetch the best match in the registry
+   *
+   * Searches for the most specific entry that matches the given query.
+   * The registry is sorted by specificity (matcher.count) in descending order,
+   * so we iterate forward to find the highest specificity match first.
+   *
+   * @param query - The query object to match against registered keys
+   * @returns The value associated with the best matching key, or undefined if no match found
+   */
   get(query) {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       if (entry.matcher(query)) {
         return entry.value;
       }
     }
+    return void 0;
   }
   /** Loop over all entries and run callback */
   forEach(callbackfn) {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       callbackfn(entry);
     }
   }
   /** Reset the items in the registry */
   clear() {
-    this.store = createSortedArray();
+    this.store = [];
   }
   /** Check if the registry is empty*/
   isRegistryEmpty() {
-    return this.store.array.length === 0;
+    return this.store.length === 0;
   }
 };
 export {

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts"],"sourcesContent":["import SortedArray from \"sorted-array\";\nimport type { Matcher } from \"./deep-partial-matcher\";\nimport { createObjectMatcher } from \"./deep-partial-matcher\";\n\nexport { createObjectMatcher } from \"./deep-partial-matcher\";\n\n/** create a matcher function that matches exactly */\nfunction createBasicMatcher(seed: any): Matcher {\n  /** a simple matcher function that only matches itself */\n  const matcher = (match: any) => seed === match;\n  matcher.count = 1;\n\n  return matcher;\n}\n\ninterface RegistryIndex<V> {\n  /** The original object we wanted to match on  */\n  key: object;\n\n  /** The value to return */\n  value: V;\n\n  /** The matcher function for this entry */\n  matcher: Matcher;\n}\n\n/** create an empty sorted array using the matcher count */\nconst createSortedArray = <V>() =>\n  new SortedArray<RegistryIndex<V>>([], (c) => c.matcher.count);\n\n/**\n * A partial match registry is a map that uses an object to \"match\" against keys.\n * More specific matches take precedence over less specific ones.\n */\nexport class Registry<V> {\n  private store = createSortedArray<V>();\n\n  constructor(initialSet?: Array<[any, V]>) {\n    initialSet?.forEach(([match, value]) => {\n      this.set(match, value);\n    });\n  }\n\n  /** Add match -> value mapping to the registry */\n  set(match: any, value: V) {\n    const matcher =\n      typeof match === \"object\"\n        ? createObjectMatcher(match)\n        : createBasicMatcher(match);\n\n    this.store.insert({\n      key: match,\n      value,\n      matcher,\n    });\n  }\n\n  /** Fetch the best match in the registry */\n  get(query: any): V | undefined {\n    for (const entry of this.store.array) {\n      if (entry.matcher(query)) {\n        return entry.value;\n      }\n    }\n  }\n\n  /** Loop over all entries and run callback */\n  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {\n    for (const entry of this.store.array) {\n      callbackfn(entry);\n    }\n  }\n\n  /** Reset the items in the registry */\n  clear() {\n    this.store = createSortedArray<V>();\n  }\n\n  /** Check if the registry is empty*/\n  isRegistryEmpty() {\n    return this.store.array.length === 0;\n  }\n}\n","import dlv from \"dlv\";\n\n/** A function that checks overlapping properties against a reference value */\nexport type Matcher = ((searchObj: object) => boolean) & {\n  /** The count represents the specificity of this matcher */\n  count: number;\n};\n\n/** Traverse an object and collect any key/value pairs including nested keys */\nfunction traverseObj(\n  object: Record<any, any>,\n  path: string[] = [],\n  pairs: Map<string[], any> = new Map(),\n): Map<string[], any> {\n  for (const key of Object.keys(object)) {\n    const val: any = object[key];\n    const nestedPath = [...path, key];\n\n    if (typeof val === \"object\") {\n      traverseObj(val, nestedPath, pairs);\n    } else {\n      pairs.set(nestedPath, val);\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Given a partial object, create a matcher function that checks if another object matches the specified properties\n * @param partialObj The partial object to match against\n * @returns A matcher function that checks if an object matches the partial object\n */\nexport function createObjectMatcher(partialObj: object): Matcher {\n  // Convert the partial object into a list of [key, value] pairs;\n  const pairs = traverseObj(partialObj);\n\n  /** Generate a function to match against all of the properties we care about */\n  const matchFunction = (searchObj: object) => {\n    for (const entry of Array.from(pairs)) {\n      const [path, value] = entry;\n\n      if (dlv(searchObj, path) !== value) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  // Keep track of the specificity of the comparator\n  matchFunction.count = pairs.size;\n\n  return matchFunction;\n}\n"],"mappings":";AAAA,OAAO,iBAAiB;;;ACAxB,OAAO,SAAS;AAShB,SAAS,YACP,QACA,OAAiB,CAAC,GAClB,QAA4B,oBAAI,IAAI,GAChB;AACpB,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,UAAM,MAAW,OAAO,GAAG;AAC3B,UAAM,aAAa,CAAC,GAAG,MAAM,GAAG;AAEhC,QAAI,OAAO,QAAQ,UAAU;AAC3B,kBAAY,KAAK,YAAY,KAAK;AAAA,IACpC,OAAO;AACL,YAAM,IAAI,YAAY,GAAG;AAAA,IAC3B;AAAA,EACF;AAEA,SAAO;AACT;AAOO,SAAS,oBAAoB,YAA6B;AAE/D,QAAM,QAAQ,YAAY,UAAU;AAGpC,QAAM,gBAAgB,CAAC,cAAsB;AAC3C,eAAW,SAAS,MAAM,KAAK,KAAK,GAAG;AACrC,YAAM,CAAC,MAAM,KAAK,IAAI;AAEtB,UAAI,IAAI,WAAW,IAAI,MAAM,OAAO;AAClC,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAGA,gBAAc,QAAQ,MAAM;AAE5B,SAAO;AACT;;;AD/CA,SAAS,mBAAmB,MAAoB;AAE9C,QAAM,UAAU,CAAC,UAAe,SAAS;AACzC,UAAQ,QAAQ;AAEhB,SAAO;AACT;AAcA,IAAM,oBAAoB,MACxB,IAAI,YAA8B,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,KAAK;AAMvD,IAAM,WAAN,MAAkB;AAAA,EAGvB,YAAY,YAA8B;AAF1C,SAAQ,QAAQ,kBAAqB;AAGnC,gBAAY,QAAQ,CAAC,CAAC,OAAO,KAAK,MAAM;AACtC,WAAK,IAAI,OAAO,KAAK;AAAA,IACvB,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,IAAI,OAAY,OAAU;AACxB,UAAM,UACJ,OAAO,UAAU,WACb,oBAAoB,KAAK,IACzB,mBAAmB,KAAK;AAE9B,SAAK,MAAM,OAAO;AAAA,MAChB,KAAK;AAAA,MACL;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA,EAGA,IAAI,OAA2B;AAC7B,eAAW,SAAS,KAAK,MAAM,OAAO;AACpC,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ,YAAqD;AAC3D,eAAW,SAAS,KAAK,MAAM,OAAO;AACpC,iBAAW,KAAK;AAAA,IAClB;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ;AACN,SAAK,QAAQ,kBAAqB;AAAA,EACpC;AAAA;AAAA,EAGA,kBAAkB;AAChB,WAAO,KAAK,MAAM,MAAM,WAAW;AAAA,EACrC;AACF;","names":[]}
+{"version":3,"sources":["../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/index.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/partial-match-registry/src/deep-partial-matcher.ts"],"sourcesContent":["import { sort } from \"fast-sort\";\nimport type { Matcher } from \"./deep-partial-matcher\";\nimport { createObjectMatcher } from \"./deep-partial-matcher\";\n\nexport { createObjectMatcher } from \"./deep-partial-matcher\";\n\n/** Minimal logger interface for registry operations */\ninterface Logger {\n  debug?: (...args: Array<any>) => void;\n}\n\n/** create a matcher function that matches exactly */\nfunction createBasicMatcher(seed: any): Matcher {\n  /** a simple matcher function that only matches itself */\n  const matcher = (match: any) => seed === match;\n  matcher.count = 1;\n\n  return matcher;\n}\n\ninterface RegistryIndex<V> {\n  /** The original object we wanted to match on  */\n  key: object;\n\n  /** The value to return */\n  value: V;\n\n  /** The matcher function for this entry */\n  matcher: Matcher;\n}\n\n/**\n * A partial match registry is a map that uses an object to \"match\" against keys.\n * More specific matches take precedence over less specific ones.\n */\nexport class Registry<V> {\n  private store: Array<RegistryIndex<V>> = [];\n  private logger?: Logger;\n\n  /**\n   * Creates a new Registry instance\n   *\n   * @param initialSet - Optional array of [key, value] tuples to populate the registry\n   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)\n   */\n  constructor(initialSet?: Array<[any, V]>, logger?: Logger) {\n    this.logger = logger;\n    initialSet?.forEach(([match, value]) => {\n      this.set(match, value);\n    });\n  }\n\n  /**\n   * Add match -> value mapping to the registry\n   *\n   * If an entry with the same specificity and matching key already exists, it will be replaced\n   * and a debug log will be emitted (if a logger is configured).\n   *\n   * @param match - The key to match against (can be a primitive or object)\n   * @param value - The value to associate with this key\n   */\n  set(match: any, value: V): void {\n    const matcher =\n      typeof match === \"object\"\n        ? createObjectMatcher(match)\n        : createBasicMatcher(match);\n\n    // Find and remove any existing entry that matches this key\n    // Use matcher to check for matching keys (handles deep equality)\n    const existingIndex = this.store.findIndex(\n      (entry) => entry.matcher(match) && matcher(entry.key),\n    );\n    if (existingIndex !== -1) {\n      this.store.splice(existingIndex, 1);\n      this.logger?.debug?.(\n        \"Registry: Replacing existing entry for key \",\n        match,\n      );\n    }\n\n    this.store.push({\n      key: match,\n      value,\n      matcher,\n    });\n\n    // Sort in descending order by matcher.count (highest specificity first)\n    this.store = sort(this.store).desc((entry) => entry.matcher.count);\n  }\n\n  /**\n   * Fetch the best match in the registry\n   *\n   * Searches for the most specific entry that matches the given query.\n   * The registry is sorted by specificity (matcher.count) in descending order,\n   * so we iterate forward to find the highest specificity match first.\n   *\n   * @param query - The query object to match against registered keys\n   * @returns The value associated with the best matching key, or undefined if no match found\n   */\n  get(query: any): V | undefined {\n    // Store is sorted by matcher.count (descending), so iterate forward\n    for (const entry of this.store) {\n      if (entry.matcher(query)) {\n        return entry.value;\n      }\n    }\n    return undefined;\n  }\n\n  /** Loop over all entries and run callback */\n  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {\n    for (const entry of this.store) {\n      callbackfn(entry);\n    }\n  }\n\n  /** Reset the items in the registry */\n  clear(): void {\n    this.store = [];\n  }\n\n  /** Check if the registry is empty*/\n  isRegistryEmpty(): boolean {\n    return this.store.length === 0;\n  }\n}\n","import dlv from \"dlv\";\n\n/** A function that checks overlapping properties against a reference value */\nexport type Matcher = ((searchObj: object) => boolean) & {\n  /** The count represents the specificity of this matcher */\n  count: number;\n};\n\n/** Traverse an object and collect any key/value pairs including nested keys */\nfunction traverseObj(\n  object: Record<any, any>,\n  path: string[] = [],\n  pairs: Map<string[], any> = new Map(),\n): Map<string[], any> {\n  for (const key of Object.keys(object)) {\n    const val: any = object[key];\n    const nestedPath = [...path, key];\n\n    /* Explicitly avoid traversing null values.\n    JavaScript's typeof null === \"object\" would otherwise cause the function to traverse null as an object\n    and throw an error. \n    \n    Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null\n    */\n    if (typeof val === \"object\" && val !== null) {\n      traverseObj(val, nestedPath, pairs);\n    } else {\n      pairs.set(nestedPath, val);\n    }\n  }\n\n  return pairs;\n}\n\n/**\n * Given a partial object, create a matcher function that checks if another object matches the specified properties\n * @param partialObj The partial object to match against\n * @returns A matcher function that checks if an object matches the partial object\n */\nexport function createObjectMatcher(partialObj: object): Matcher {\n  // Convert the partial object into a list of [key, value] pairs;\n  const pairs = traverseObj(partialObj);\n\n  /** Generate a function to match against all of the properties we care about */\n  const matchFunction = (searchObj: object) => {\n    for (const entry of Array.from(pairs)) {\n      const [path, value] = entry;\n\n      if (dlv(searchObj, path) !== value) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  // Keep track of the specificity of the comparator\n  matchFunction.count = pairs.size;\n\n  return matchFunction;\n}\n"],"mappings":";AAAA,SAAS,YAAY;;;ACArB,OAAO,SAAS;AAShB,SAAS,YACP,QACA,OAAiB,CAAC,GAClB,QAA4B,oBAAI,IAAI,GAChB;AACpB,aAAW,OAAO,OAAO,KAAK,MAAM,GAAG;AACrC,UAAM,MAAW,OAAO,GAAG;AAC3B,UAAM,aAAa,CAAC,GAAG,MAAM,GAAG;AAQhC,QAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,kBAAY,KAAK,YAAY,KAAK;AAAA,IACpC,OAAO;AACL,YAAM,IAAI,YAAY,GAAG;AAAA,IAC3B;AAAA,EACF;AAEA,SAAO;AACT;AAOO,SAAS,oBAAoB,YAA6B;AAE/D,QAAM,QAAQ,YAAY,UAAU;AAGpC,QAAM,gBAAgB,CAAC,cAAsB;AAC3C,eAAW,SAAS,MAAM,KAAK,KAAK,GAAG;AACrC,YAAM,CAAC,MAAM,KAAK,IAAI;AAEtB,UAAI,IAAI,WAAW,IAAI,MAAM,OAAO;AAClC,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAGA,gBAAc,QAAQ,MAAM;AAE5B,SAAO;AACT;;;ADhDA,SAAS,mBAAmB,MAAoB;AAE9C,QAAM,UAAU,CAAC,UAAe,SAAS;AACzC,UAAQ,QAAQ;AAEhB,SAAO;AACT;AAiBO,IAAM,WAAN,MAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUvB,YAAY,YAA8B,QAAiB;AAT3D,SAAQ,QAAiC,CAAC;AAUxC,SAAK,SAAS;AACd,gBAAY,QAAQ,CAAC,CAAC,OAAO,KAAK,MAAM;AACtC,WAAK,IAAI,OAAO,KAAK;AAAA,IACvB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,IAAI,OAAY,OAAgB;AAC9B,UAAM,UACJ,OAAO,UAAU,WACb,oBAAoB,KAAK,IACzB,mBAAmB,KAAK;AAI9B,UAAM,gBAAgB,KAAK,MAAM;AAAA,MAC/B,CAAC,UAAU,MAAM,QAAQ,KAAK,KAAK,QAAQ,MAAM,GAAG;AAAA,IACtD;AACA,QAAI,kBAAkB,IAAI;AACxB,WAAK,MAAM,OAAO,eAAe,CAAC;AAClC,WAAK,QAAQ;AAAA,QACX;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,SAAK,MAAM,KAAK;AAAA,MACd,KAAK;AAAA,MACL;AAAA,MACA;AAAA,IACF,CAAC;AAGD,SAAK,QAAQ,KAAK,KAAK,KAAK,EAAE,KAAK,CAAC,UAAU,MAAM,QAAQ,KAAK;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,IAAI,OAA2B;AAE7B,eAAW,SAAS,KAAK,OAAO;AAC9B,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,MAAM;AAAA,MACf;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAQ,YAAqD;AAC3D,eAAW,SAAS,KAAK,OAAO;AAC9B,iBAAW,KAAK;AAAA,IAClB;AAAA,EACF;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,QAAQ,CAAC;AAAA,EAChB;AAAA;AAAA,EAGA,kBAA2B;AACzB,WAAO,KAAK,MAAM,WAAW;AAAA,EAC/B;AACF;","names":[]}

package/package.json

@@ -6,7 +6,7 @@
     "types"
   ],
   "name": "@player-ui/partial-match-registry",
-  "version": "0.15.3",
+  "version": "0.15.4--canary.881.37421",
   "main": "dist/cjs/index.cjs",
   "module": "dist/index.legacy-esm.js",
   "types": "types/index.d.ts",
@@ -23,7 +23,7 @@
   "dependencies": {
     "@types/dlv": "^1.1.4",
     "dlv": "^1.1.3",
-    "sorted-array": "^2.0.4",
+    "fast-sort": "^3.4.1",
     "tslib": "^2.6.2"
   },
   "peerDependencies": {}

package/src/__tests__/matcher.test.ts

@@ -7,3 +7,27 @@ test("works on basic objects", () => {
   expect(matcher({ foo: "bar" })).toBe(true);
   expect(matcher({ foo: "bar", bar: "baz" })).toBe(true);
 });
+
+test("handles null values correctly", () => {
+  // Test matching on null value
+  const matcherWithNull = createObjectMatcher({ foo: null });
+  expect(matcherWithNull({ foo: null })).toBe(true);
+  expect(matcherWithNull({ foo: "bar" })).toBe(false);
+  expect(matcherWithNull({})).toBe(false);
+
+  // Test matching on combination of null and non-null values
+  const matcherMixed = createObjectMatcher({ foo: null, bar: "baz" });
+  expect(matcherMixed({ foo: null, bar: "baz" })).toBe(true);
+  expect(matcherMixed({ foo: null, bar: "other" })).toBe(false);
+  expect(matcherMixed({ foo: "something", bar: "baz" })).toBe(false);
+});
+
+test("handles undefined values correctly", () => {
+  // Test matching on undefined value
+  // Note: dlv treats missing properties the same as undefined, so { foo: undefined } matches {}
+  const matcherWithUndefined = createObjectMatcher({ foo: undefined });
+  expect(matcherWithUndefined({ foo: undefined })).toBe(true);
+  expect(matcherWithUndefined({})).toBe(true); // Missing property is treated as undefined
+  expect(matcherWithUndefined({ foo: "bar" })).toBe(false);
+  expect(matcherWithUndefined({ foo: null })).toBe(false);
+});

package/src/__tests__/registry.test.ts

@@ -1,4 +1,4 @@
-import { test, expect, beforeEach } from "vitest";
+import { test, expect, beforeEach, vi } from "vitest";
 
 import { Registry } from "..";
 
@@ -27,7 +27,7 @@ test("falls back to a partially matched object", () => {
   expect(registry.get({ foo: "bar", bar: "baz" })).toBe("blah");
 });
 
-test("uses more specific match if one exists", () => {
+test("uses more specific match if one exists where more specific one is added last", () => {
   const query = { foo: "bar", metaData: { role: "baz" } };
   registry.set({ foo: "bar" }, "blah");
   expect(registry.get(query)).toBe("blah");
@@ -35,6 +35,13 @@ test("uses more specific match if one exists", () => {
   expect(registry.get(query)).toBe("stuff");
 });
 
+test("uses more specific match if one exists where more specific one is added first", () => {
+  const query = { foo: "bar", metaData: { role: "baz" } };
+  registry.set({ foo: "bar", metaData: { role: "baz" } }, "stuff");
+  registry.set({ foo: "bar" }, "blah");
+  expect(registry.get(query)).toBe("stuff");
+});
+
 test("works with seed data", () => {
   registry = new Registry([
     [{ type: "foo" }, "foo-bar"],
@@ -67,3 +74,61 @@ test("check if registry is empty", () => {
   expect(registry.isRegistryEmpty()).toBe(false);
   expect(emptyRegistry.isRegistryEmpty()).toBe(true);
 });
+
+test("replacement only replaces exact matches, not fuzzy matches", () => {
+  registry.set({ foo: "bar" }, "exact-match");
+  registry.set({ foo: "bar", baz: "qux" }, "more-specific-match");
+
+  // Override the exact match - should only remove the exact match
+  registry.set({ foo: "bar" }, "new-exact-match");
+
+  // The exact match should be replaced
+  expect(registry.get({ foo: "bar" })).toBe("new-exact-match");
+
+  // The more specific match should still exist and be found by fuzzy matching
+  expect(registry.get({ foo: "bar", baz: "qux" })).toBe("more-specific-match");
+
+  // Now override the more specific match
+  registry.set({ foo: "bar", baz: "qux" }, "new-specific-match");
+
+  // The more specific match should be replaced
+  expect(registry.get({ foo: "bar", baz: "qux" })).toBe("new-specific-match");
+
+  // The exact match should still exist
+  expect(registry.get({ foo: "bar" })).toBe("new-exact-match");
+});
+
+test("logs debug message when initialSet has duplicate keys", () => {
+  const mockDebug = vi.fn();
+  const logger = { debug: mockDebug };
+
+  // Create registry with duplicate keys in initialSet
+  const registryWithDuplicates = new Registry<string>(
+    [
+      [{ type: "action" }, "first-value"],
+      [{ type: "action" }, "second-value"], // Duplicate - should trigger log
+      [{ type: "other" }, "other-value"],
+      [{ type: "action" }, "third-value"], // Another duplicate - should trigger log again
+    ],
+    logger,
+  );
+
+  // Should have logged twice for the two replacements
+  expect(mockDebug).toHaveBeenCalledTimes(2);
+
+  // Verify the log messages
+  expect(mockDebug).toHaveBeenNthCalledWith(
+    1,
+    "Registry: Replacing existing entry for key ",
+    { type: "action" },
+  );
+  expect(mockDebug).toHaveBeenNthCalledWith(
+    2,
+    "Registry: Replacing existing entry for key ",
+    { type: "action" },
+  );
+
+  // Verify the final value is the last one set
+  expect(registryWithDuplicates.get({ type: "action" })).toBe("third-value");
+  expect(registryWithDuplicates.get({ type: "other" })).toBe("other-value");
+});

package/src/deep-partial-matcher.ts

@@ -16,7 +16,13 @@ function traverseObj(
     const val: any = object[key];
     const nestedPath = [...path, key];
 
-    if (typeof val === "object") {
+    /* Explicitly avoid traversing null values.
+    JavaScript's typeof null === "object" would otherwise cause the function to traverse null as an object
+    and throw an error. 
+    
+    Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null
+    */
+    if (typeof val === "object" && val !== null) {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);

package/src/index.ts

@@ -1,9 +1,14 @@
-import SortedArray from "sorted-array";
+import { sort } from "fast-sort";
 import type { Matcher } from "./deep-partial-matcher";
 import { createObjectMatcher } from "./deep-partial-matcher";
 
 export { createObjectMatcher } from "./deep-partial-matcher";
 
+/** Minimal logger interface for registry operations */
+interface Logger {
+  debug?: (...args: Array<any>) => void;
+}
+
 /** create a matcher function that matches exactly */
 function createBasicMatcher(seed: any): Matcher {
   /** a simple matcher function that only matches itself */
@@ -24,60 +29,99 @@ interface RegistryIndex<V> {
   matcher: Matcher;
 }
 
-/** create an empty sorted array using the matcher count */
-const createSortedArray = <V>() =>
-  new SortedArray<RegistryIndex<V>>([], (c) => c.matcher.count);
-
 /**
  * A partial match registry is a map that uses an object to "match" against keys.
  * More specific matches take precedence over less specific ones.
  */
 export class Registry<V> {
-  private store = createSortedArray<V>();
+  private store: Array<RegistryIndex<V>> = [];
+  private logger?: Logger;
 
-  constructor(initialSet?: Array<[any, V]>) {
+  /**
+   * Creates a new Registry instance
+   *
+   * @param initialSet - Optional array of [key, value] tuples to populate the registry
+   * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)
+   */
+  constructor(initialSet?: Array<[any, V]>, logger?: Logger) {
+    this.logger = logger;
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
 
-  /** Add match -> value mapping to the registry */
-  set(match: any, value: V) {
+  /**
+   * Add match -> value mapping to the registry
+   *
+   * If an entry with the same specificity and matching key already exists, it will be replaced
+   * and a debug log will be emitted (if a logger is configured).
+   *
+   * @param match - The key to match against (can be a primitive or object)
+   * @param value - The value to associate with this key
+   */
+  set(match: any, value: V): void {
     const matcher =
       typeof match === "object"
         ? createObjectMatcher(match)
         : createBasicMatcher(match);
 
-    this.store.insert({
+    // Find and remove any existing entry that matches this key
+    // Use matcher to check for matching keys (handles deep equality)
+    const existingIndex = this.store.findIndex(
+      (entry) => entry.matcher(match) && matcher(entry.key),
+    );
+    if (existingIndex !== -1) {
+      this.store.splice(existingIndex, 1);
+      this.logger?.debug?.(
+        "Registry: Replacing existing entry for key ",
+        match,
+      );
+    }
+
+    this.store.push({
       key: match,
       value,
       matcher,
     });
+
+    // Sort in descending order by matcher.count (highest specificity first)
+    this.store = sort(this.store).desc((entry) => entry.matcher.count);
   }
 
-  /** Fetch the best match in the registry */
+  /**
+   * Fetch the best match in the registry
+   *
+   * Searches for the most specific entry that matches the given query.
+   * The registry is sorted by specificity (matcher.count) in descending order,
+   * so we iterate forward to find the highest specificity match first.
+   *
+   * @param query - The query object to match against registered keys
+   * @returns The value associated with the best matching key, or undefined if no match found
+   */
   get(query: any): V | undefined {
-    for (const entry of this.store.array) {
+    // Store is sorted by matcher.count (descending), so iterate forward
+    for (const entry of this.store) {
       if (entry.matcher(query)) {
         return entry.value;
       }
     }
+    return undefined;
   }
 
   /** Loop over all entries and run callback */
   forEach(callbackfn: (value: RegistryIndex<V>) => void): void {
-    for (const entry of this.store.array) {
+    for (const entry of this.store) {
       callbackfn(entry);
     }
   }
 
   /** Reset the items in the registry */
-  clear() {
-    this.store = createSortedArray<V>();
+  clear(): void {
+    this.store = [];
   }
 
   /** Check if the registry is empty*/
-  isRegistryEmpty() {
-    return this.store.array.length === 0;
+  isRegistryEmpty(): boolean {
+    return this.store.length === 0;
   }
 }

package/types/index.d.ts

@@ -1,5 +1,9 @@
 import type { Matcher } from "./deep-partial-matcher";
 export { createObjectMatcher } from "./deep-partial-matcher";
+/** Minimal logger interface for registry operations */
+interface Logger {
+    debug?: (...args: Array<any>) => void;
+}
 interface RegistryIndex<V> {
     /** The original object we wanted to match on  */
     key: object;
@@ -14,10 +18,34 @@ interface RegistryIndex<V> {
  */
 export declare class Registry<V> {
     private store;
-    constructor(initialSet?: Array<[any, V]>);
-    /** Add match -> value mapping to the registry */
+    private logger?;
+    /**
+     * Creates a new Registry instance
+     *
+     * @param initialSet - Optional array of [key, value] tuples to populate the registry
+     * @param logger - Optional logger instance for debug logging (e.g., when entries are replaced)
+     */
+    constructor(initialSet?: Array<[any, V]>, logger?: Logger);
+    /**
+     * Add match -> value mapping to the registry
+     *
+     * If an entry with the same specificity and matching key already exists, it will be replaced
+     * and a debug log will be emitted (if a logger is configured).
+     *
+     * @param match - The key to match against (can be a primitive or object)
+     * @param value - The value to associate with this key
+     */
     set(match: any, value: V): void;
-    /** Fetch the best match in the registry */
+    /**
+     * Fetch the best match in the registry
+     *
+     * Searches for the most specific entry that matches the given query.
+     * The registry is sorted by specificity (matcher.count) in descending order,
+     * so we iterate forward to find the highest specificity match first.
+     *
+     * @param query - The query object to match against registered keys
+     * @returns The value associated with the best matching key, or undefined if no match found
+     */
     get(query: any): V | undefined;
     /** Loop over all entries and run callback */
     forEach(callbackfn: (value: RegistryIndex<V>) => void): void;