@player-ui/partial-match-registry 0.15.5--canary.888.37918 → 0.15.5

package/dist/Registry.native.js

@@ -81,23 +81,6 @@ 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;
@@ -105,7 +88,7 @@ var Registry = function() {
     };
     var createObjectMatcher = function createObjectMatcher(partialObj) {
         var pairs = traverseObj(partialObj);
-        var matchFunction = function(searchObj) {
+        var matchFunction = function matchFunction(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){
@@ -136,30 +119,39 @@ 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(match) {
+        var matcher = function matcher(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 __export = function(target, all) {
+    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) {
         for(var name in all)__defProp(target, name, {
             get: all[name],
             enumerable: true
         });
     };
-    var __copyProps = function(to, from, except, desc) {
+    var __copyProps = function __copyProps(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: function get() {
                             return from[key];
                         },
                         enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
@@ -183,117 +175,113 @@ var Registry = function() {
         }
         return to;
     };
-    var __toCommonJS = function(mod) {
+    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) {
         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() {
+        Registry: function Registry1() {
             return Registry;
         },
-        createObjectMatcher: function() {
+        createObjectMatcher: function createObjectMatcher1() {
             return createObjectMatcher;
         }
     });
-    // ../../../../../../../../../../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
-    });
+    var import_sorted_array = __toESM(require_sorted_array());
     // ../../../../../../../../../../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();
@@ -305,7 +293,7 @@ var Registry = function() {
                 var nestedPath = _to_consumable_array(path).concat([
                     key
                 ]);
-                if ((typeof val === "undefined" ? "undefined" : _type_of(val)) === "object" && val !== null) {
+                if ((typeof val === "undefined" ? "undefined" : _type_of(val)) === "object") {
                     traverseObj(val, nestedPath, pairs);
                 } else {
                     pairs.set(nestedPath, val);
@@ -327,12 +315,16 @@ 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, logger) {
+        function Registry(initialSet) {
             var _this = this;
             _class_call_check(this, Registry);
-            this.store = [];
-            this.logger = logger;
+            this.store = createSortedArray();
             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);
@@ -340,50 +332,22 @@ var Registry = function() {
         }
         _create_class(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
-     */ key: "set",
+                /** Add match -> value mapping to the registry */ key: "set",
                 value: function set(match, value) {
                     var matcher = (typeof match === "undefined" ? "undefined" : _type_of(match)) === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-                    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({
+                    this.store.insert({
                         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
-     *
-     * 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",
+                /** Fetch the best match in the registry */ key: "get",
                 value: function get(query) {
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
-                        for(var _iterator = this.store[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        for(var _iterator = this.store.array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             var entry = _step.value;
                             if (entry.matcher(query)) {
                                 return entry.value;
@@ -403,7 +367,6 @@ var Registry = function() {
                             }
                         }
                     }
-                    return void 0;
                 }
             },
             {
@@ -411,7 +374,7 @@ var Registry = function() {
                 value: function forEach(callbackfn) {
                     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
-                        for(var _iterator = this.store[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        for(var _iterator = this.store.array[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             var entry = _step.value;
                             callbackfn(entry);
                         }
@@ -434,13 +397,13 @@ var Registry = function() {
             {
                 /** Reset the items in the registry */ key: "clear",
                 value: function clear() {
-                    this.store = [];
+                    this.store = createSortedArray();
                 }
             },
             {
                 /** Check if the registry is empty*/ key: "isRegistryEmpty",
                 value: function isRegistryEmpty() {
-                    return this.store.length === 0;
+                    return this.store.array.length === 0;
                 }
             }
         ]);

package/dist/Registry.native.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/circleci/.cache/bazel/_bazel_circleci/e8362d362e14c7d23506d1dfa3aea8b8/sandbox/processwrapper-sandbox/2053/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"]}
+{"version":3,"sources":["/home/circleci/.cache/bazel/_bazel_circleci/e8362d362e14c7d23506d1dfa3aea8b8/sandbox/processwrapper-sandbox/2303/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"]}

package/dist/cjs/index.cjs

@@ -34,7 +34,7 @@ __export(src_exports, {
   createObjectMatcher: () => createObjectMatcher
 });
 module.exports = __toCommonJS(src_exports);
-var import_fast_sort = require("fast-sort");
+var import_sorted_array = __toESM(require("sorted-array"));
 
 // ../../../../../../../../../../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" && val !== null) {
+    if (typeof val === "object") {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);
@@ -71,79 +71,44 @@ function createBasicMatcher(seed) {
   matcher.count = 1;
   return matcher;
 }
+var createSortedArray = () => new import_sorted_array.default([], (c) => c.matcher.count);
 var Registry = class {
-  /**
-   * 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;
+  constructor(initialSet) {
+    this.store = createSortedArray();
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
-  /**
-   * 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
-   */
+  /** Add match -> value mapping to the registry */
   set(match, value) {
     const matcher = typeof match === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-    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({
+    this.store.insert({
       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
-   *
-   * 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
-   */
+  /** Fetch the best match in the registry */
   get(query) {
-    for (const entry of this.store) {
+    for (const entry of this.store.array) {
       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) {
+    for (const entry of this.store.array) {
       callbackfn(entry);
     }
   }
   /** Reset the items in the registry */
   clear() {
-    this.store = [];
+    this.store = createSortedArray();
   }
   /** Check if the registry is empty*/
   isRegistryEmpty() {
-    return this.store.length === 0;
+    return this.store.array.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 { 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"]}
+{"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"]}

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 { sort } from "fast-sort";
+import SortedArray from "sorted-array";
 
 // ../../../../../../../../../../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" && val !== null) {
+    if (typeof val === "object") {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);
@@ -36,79 +36,44 @@ function createBasicMatcher(seed) {
   matcher.count = 1;
   return matcher;
 }
+var createSortedArray = () => new SortedArray([], (c) => c.matcher.count);
 var Registry = class {
-  /**
-   * 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;
+  constructor(initialSet) {
+    this.store = createSortedArray();
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
-  /**
-   * 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
-   */
+  /** Add match -> value mapping to the registry */
   set(match, value) {
     const matcher = typeof match === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-    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({
+    this.store.insert({
       key: match,
       value,
       matcher
     });
-    this.store = sort(this.store).desc((entry) => entry.matcher.count);
   }
-  /**
-   * 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
-   */
+  /** Fetch the best match in the registry */
   get(query) {
-    for (const entry of this.store) {
+    for (const entry of this.store.array) {
       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) {
+    for (const entry of this.store.array) {
       callbackfn(entry);
     }
   }
   /** Reset the items in the registry */
   clear() {
-    this.store = [];
+    this.store = createSortedArray();
   }
   /** Check if the registry is empty*/
   isRegistryEmpty() {
-    return this.store.length === 0;
+    return this.store.array.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 { sort } from "fast-sort";
+import SortedArray from "sorted-array";
 
 // ../../../../../../../../../../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" && val !== null) {
+    if (typeof val === "object") {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);
@@ -36,79 +36,44 @@ function createBasicMatcher(seed) {
   matcher.count = 1;
   return matcher;
 }
+var createSortedArray = () => new SortedArray([], (c) => c.matcher.count);
 var Registry = class {
-  /**
-   * 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;
+  constructor(initialSet) {
+    this.store = createSortedArray();
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
-  /**
-   * 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
-   */
+  /** Add match -> value mapping to the registry */
   set(match, value) {
     const matcher = typeof match === "object" ? createObjectMatcher(match) : createBasicMatcher(match);
-    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({
+    this.store.insert({
       key: match,
       value,
       matcher
     });
-    this.store = sort(this.store).desc((entry) => entry.matcher.count);
   }
-  /**
-   * 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
-   */
+  /** Fetch the best match in the registry */
   get(query) {
-    for (const entry of this.store) {
+    for (const entry of this.store.array) {
       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) {
+    for (const entry of this.store.array) {
       callbackfn(entry);
     }
   }
   /** Reset the items in the registry */
   clear() {
-    this.store = [];
+    this.store = createSortedArray();
   }
   /** Check if the registry is empty*/
   isRegistryEmpty() {
-    return this.store.length === 0;
+    return this.store.array.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 { 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":[]}
+{"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":[]}

package/package.json

@@ -6,7 +6,7 @@
     "types"
   ],
   "name": "@player-ui/partial-match-registry",
-  "version": "0.15.5--canary.888.37918",
+  "version": "0.15.5",
   "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",
-    "fast-sort": "^3.4.1",
+    "sorted-array": "^2.0.4",
     "tslib": "^2.6.2"
   },
   "peerDependencies": {}

package/src/__tests__/matcher.test.ts

@@ -7,27 +7,3 @@ 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, vi } from "vitest";
+import { test, expect, beforeEach } 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 where more specific one is added last", () => {
+test("uses more specific match if one exists", () => {
   const query = { foo: "bar", metaData: { role: "baz" } };
   registry.set({ foo: "bar" }, "blah");
   expect(registry.get(query)).toBe("blah");
@@ -35,13 +35,6 @@ test("uses more specific match if one exists where more specific one is added la
   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"],
@@ -74,61 +67,3 @@ 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,13 +16,7 @@ function traverseObj(
     const val: any = object[key];
     const nestedPath = [...path, key];
 
-    /* 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) {
+    if (typeof val === "object") {
       traverseObj(val, nestedPath, pairs);
     } else {
       pairs.set(nestedPath, val);

package/src/index.ts

@@ -1,14 +1,9 @@
-import { sort } from "fast-sort";
+import SortedArray from "sorted-array";
 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 */
@@ -29,99 +24,60 @@ 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: Array<RegistryIndex<V>> = [];
-  private logger?: Logger;
+  private store = createSortedArray<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;
+  constructor(initialSet?: Array<[any, V]>) {
     initialSet?.forEach(([match, value]) => {
       this.set(match, value);
     });
   }
 
-  /**
-   * 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 {
+  /** Add match -> value mapping to the registry */
+  set(match: any, value: V) {
     const matcher =
       typeof match === "object"
         ? createObjectMatcher(match)
         : createBasicMatcher(match);
 
-    // 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({
+    this.store.insert({
       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
-   *
-   * 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
-   */
+  /** Fetch the best match in the registry */
   get(query: any): V | undefined {
-    // Store is sorted by matcher.count (descending), so iterate forward
-    for (const entry of this.store) {
+    for (const entry of this.store.array) {
       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) {
+    for (const entry of this.store.array) {
       callbackfn(entry);
     }
   }
 
   /** Reset the items in the registry */
-  clear(): void {
-    this.store = [];
+  clear() {
+    this.store = createSortedArray<V>();
   }
 
   /** Check if the registry is empty*/
-  isRegistryEmpty(): boolean {
-    return this.store.length === 0;
+  isRegistryEmpty() {
+    return this.store.array.length === 0;
   }
 }

package/types/index.d.ts

@@ -1,9 +1,5 @@
 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;
@@ -18,34 +14,10 @@ interface RegistryIndex<V> {
  */
 export declare class Registry<V> {
     private store;
-    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
-     */
+    constructor(initialSet?: Array<[any, V]>);
+    /** Add match -> value mapping to the registry */
     set(match: any, value: V): void;
-    /**
-     * 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
-     */
+    /** Fetch the best match in the registry */
     get(query: any): V | undefined;
     /** Loop over all entries and run callback */
     forEach(callbackfn: (value: RegistryIndex<V>) => void): void;