@kubb/agent 0.0.0-canary-20260217115709

package/.output/server/node_modules/minimatch/package.json

@@ -0,0 +1,33 @@
+{
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "name": "minimatch",
+  "description": "a glob matcher in javascript",
+  "version": "3.1.2",
+  "publishConfig": {
+    "tag": "v3-legacy"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/minimatch.git"
+  },
+  "main": "minimatch.js",
+  "scripts": {
+    "test": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --all; git push origin --tags"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {
+    "brace-expansion": "^1.1.7"
+  },
+  "devDependencies": {
+    "tap": "^15.1.6"
+  },
+  "license": "ISC",
+  "files": [
+    "minimatch.js"
+  ]
+}

package/.output/server/node_modules/natural-orderby/dist/main.js

@@ -0,0 +1,19 @@
+/**
+ * natural-orderby v5.0.0
+ *
+ * Copyright (c) Olaf Ennen
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+/* eslint-disable n/no-missing-require */
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./umd/natural-orderby.production.min.js');
+} else {
+  module.exports = require('./umd/natural-orderby.development.js');
+}

package/.output/server/node_modules/natural-orderby/dist/umd/natural-orderby.development.js

@@ -0,0 +1,420 @@
+/**
+ * natural-orderby v5.0.0
+ *
+ * Copyright (c) Olaf Ennen
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.naturalOrderBy = {}));
+})(this, (function (exports) { 'use strict';
+
+  var compareNumbers = function compareNumbers(numberA, numberB) {
+    if (numberA < numberB) {
+      return -1;
+    }
+    if (numberA > numberB) {
+      return 1;
+    }
+    return 0;
+  };
+
+  var compareUnicode = function compareUnicode(stringA, stringB, locale) {
+    var result = stringA.localeCompare(stringB, locale);
+    return result ? result / Math.abs(result) : 0;
+  };
+
+  var RE_NUMBERS = /(^0x[\da-fA-F]+$|^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?!\.\d+)(?=\D|\s|$))|\d+)/g;
+  var RE_LEADING_OR_TRAILING_WHITESPACES = /^\s+|\s+$/g; // trim pre-post whitespace
+  var RE_WHITESPACES = /\s+/g; // normalize all whitespace to single ' ' character
+  var RE_INT_OR_FLOAT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/; // identify integers and floats
+  var RE_DATE = /(^([\w ]+,?[\w ]+)?[\w ]+,?[\w ]+\d+:\d+(:\d+)?[\w ]?|^\d{1,4}[/-]\d{1,4}[/-]\d{1,4}|^\w+, \w+ \d+, \d{4})/; // identify date strings
+  var RE_LEADING_ZERO = /^0+[1-9]{1}[0-9]*$/;
+  // eslint-disable-next-line no-control-regex
+  var RE_UNICODE_CHARACTERS = /[^\x00-\x80]/;
+
+  var stringCompare = function stringCompare(stringA, stringB) {
+    if (stringA < stringB) {
+      return -1;
+    }
+    if (stringA > stringB) {
+      return 1;
+    }
+    return 0;
+  };
+
+  var compareChunks = function compareChunks(chunksA, chunksB, locale) {
+    var lengthA = chunksA.length;
+    var lengthB = chunksB.length;
+    var size = Math.min(lengthA, lengthB);
+    for (var i = 0; i < size; i++) {
+      var chunkA = chunksA[i];
+      var chunkB = chunksB[i];
+      if (chunkA.normalizedString !== chunkB.normalizedString) {
+        if (chunkA.normalizedString === '' !== (chunkB.normalizedString === '')) {
+          // empty strings have lowest value
+          return chunkA.normalizedString === '' ? -1 : 1;
+        }
+        if (chunkA.parsedNumber !== undefined && chunkB.parsedNumber !== undefined) {
+          // compare numbers
+          var result = compareNumbers(chunkA.parsedNumber, chunkB.parsedNumber);
+          if (result === 0) {
+            // compare string value, if parsed numbers are equal
+            // Example:
+            // chunkA = { parsedNumber: 1, normalizedString: "001" }
+            // chunkB = { parsedNumber: 1, normalizedString: "01" }
+            // chunkA.parsedNumber === chunkB.parsedNumber
+            // chunkA.normalizedString < chunkB.normalizedString
+            return stringCompare(chunkA.normalizedString, chunkB.normalizedString);
+          }
+          return result;
+        } else if (chunkA.parsedNumber !== undefined || chunkB.parsedNumber !== undefined) {
+          // number < string
+          return chunkA.parsedNumber !== undefined ? -1 : 1;
+        } else if (RE_UNICODE_CHARACTERS.test(chunkA.normalizedString + chunkB.normalizedString)) {
+          // use locale comparison only if one of the chunks contains unicode characters
+          return compareUnicode(chunkA.normalizedString, chunkB.normalizedString, locale);
+        } else {
+          // use common string comparison for performance reason
+          return stringCompare(chunkA.normalizedString, chunkB.normalizedString);
+        }
+      }
+    }
+    // if the chunks are equal so far, the one which has more chunks is greater than the other one
+    if (lengthA > size || lengthB > size) {
+      return lengthA <= size ? -1 : 1;
+    }
+    return 0;
+  };
+
+  var compareOtherTypes = function compareOtherTypes(valueA, valueB) {
+    if (!valueA.chunks ? valueB.chunks : !valueB.chunks) {
+      return !valueA.chunks ? 1 : -1;
+    }
+    if (valueA.isNaN ? !valueB.isNaN : valueB.isNaN) {
+      return valueA.isNaN ? -1 : 1;
+    }
+    if (valueA.isSymbol ? !valueB.isSymbol : valueB.isSymbol) {
+      return valueA.isSymbol ? -1 : 1;
+    }
+    if (valueA.isObject ? !valueB.isObject : valueB.isObject) {
+      return valueA.isObject ? -1 : 1;
+    }
+    if (valueA.isArray ? !valueB.isArray : valueB.isArray) {
+      return valueA.isArray ? -1 : 1;
+    }
+    if (valueA.isFunction ? !valueB.isFunction : valueB.isFunction) {
+      return valueA.isFunction ? -1 : 1;
+    }
+    if (valueA.isNull ? !valueB.isNull : valueB.isNull) {
+      return valueA.isNull ? -1 : 1;
+    }
+    return 0;
+  };
+
+  var compareValues = function compareValues(valueA, valueB, locale) {
+    if (valueA.value === valueB.value) {
+      return 0;
+    }
+    if (valueA.parsedNumber !== undefined && valueB.parsedNumber !== undefined) {
+      return compareNumbers(valueA.parsedNumber, valueB.parsedNumber);
+    }
+    if (valueA.chunks && valueB.chunks) {
+      return compareChunks(valueA.chunks, valueB.chunks, locale);
+    }
+    return compareOtherTypes(valueA, valueB);
+  };
+
+  var normalizeAlphaChunk = function normalizeAlphaChunk(chunk) {
+    return chunk.replace(RE_WHITESPACES, ' ').replace(RE_LEADING_OR_TRAILING_WHITESPACES, '');
+  };
+
+  var parseNumber = function parseNumber(value) {
+    if (value.length !== 0) {
+      var parsedNumber = Number(value.replace(/_/g, ''));
+      if (!Number.isNaN(parsedNumber)) {
+        return parsedNumber;
+      }
+    }
+    return undefined;
+  };
+
+  var normalizeNumericChunk = function normalizeNumericChunk(chunk, index, chunks) {
+    if (RE_INT_OR_FLOAT.test(chunk)) {
+      // don´t parse a number, if there´s a preceding decimal point
+      // to keep significance
+      // e.g. 1.0020, 1.020
+      if (!RE_LEADING_ZERO.test(chunk) || index === 0 || chunks[index - 1] !== '.') {
+        return parseNumber(chunk) || 0;
+      }
+    }
+    return undefined;
+  };
+
+  var createChunkMap = function createChunkMap(chunk, index, chunks) {
+    return {
+      parsedNumber: normalizeNumericChunk(chunk, index, chunks),
+      normalizedString: normalizeAlphaChunk(chunk)
+    };
+  };
+
+  var createChunks = function createChunks(value) {
+    return value.replace(RE_NUMBERS, '\0$1\0').replace(/\0$/, '').replace(/^\0/, '').split('\0');
+  };
+
+  var createChunkMaps = function createChunkMaps(value) {
+    var chunksMaps = createChunks(value).map(createChunkMap);
+    return chunksMaps;
+  };
+
+  var isFunction = function isFunction(value) {
+    return typeof value === 'function';
+  };
+
+  var isNaN = function isNaN(value) {
+    return Number.isNaN(value) || value instanceof Number && Number.isNaN(value.valueOf());
+  };
+
+  var isNull = function isNull(value) {
+    return value === null;
+  };
+
+  var isObject = function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Number) && !(value instanceof String) && !(value instanceof Boolean) && !(value instanceof Date);
+  };
+
+  var isSymbol = function isSymbol(value) {
+    return typeof value === 'symbol';
+  };
+
+  var isUndefined = function isUndefined(value) {
+    return value === undefined;
+  };
+
+  var parseDate = function parseDate(value) {
+    try {
+      var parsedDate = Date.parse(value);
+      if (!Number.isNaN(parsedDate)) {
+        if (RE_DATE.test(value)) {
+          return parsedDate;
+        }
+      }
+      return undefined;
+    } catch (_unused) {
+      return undefined;
+    }
+  };
+
+  var numberify = function numberify(value) {
+    var parsedNumber = parseNumber(value);
+    if (parsedNumber !== undefined) {
+      return parsedNumber;
+    }
+    return parseDate(value);
+  };
+
+  var stringify = function stringify(value) {
+    if (typeof value === 'boolean' || value instanceof Boolean) {
+      return Number(value).toString();
+    }
+    if (typeof value === 'number' || value instanceof Number) {
+      return value.toString();
+    }
+    if (value instanceof Date) {
+      return value.getTime().toString();
+    }
+    if (typeof value === 'string' || value instanceof String) {
+      return value.toLowerCase().replace(RE_LEADING_OR_TRAILING_WHITESPACES, '');
+    }
+    return '';
+  };
+
+  var getMappedValueRecord = function getMappedValueRecord(value) {
+    if (typeof value === 'string' || value instanceof String || (typeof value === 'number' || value instanceof Number) && !isNaN(value) || typeof value === 'boolean' || value instanceof Boolean || value instanceof Date) {
+      var stringValue = stringify(value);
+      var parsedNumber = numberify(stringValue);
+      var chunks = createChunkMaps(parsedNumber ? "" + parsedNumber : stringValue);
+      return {
+        parsedNumber: parsedNumber,
+        chunks: chunks,
+        value: value
+      };
+    }
+    return {
+      isArray: Array.isArray(value),
+      isFunction: isFunction(value),
+      isNaN: isNaN(value),
+      isNull: isNull(value),
+      isObject: isObject(value),
+      isSymbol: isSymbol(value),
+      isUndefined: isUndefined(value),
+      value: value
+    };
+  };
+
+  var baseCompare = function baseCompare(options) {
+    return function (valueA, valueB) {
+      var a = getMappedValueRecord(valueA);
+      var b = getMappedValueRecord(valueB);
+      var result = compareValues(a, b, options.locale);
+      return result * (options.order === 'desc' ? -1 : 1);
+    };
+  };
+
+  var isValidOrder = function isValidOrder(value) {
+    return typeof value === 'string' && (value === 'asc' || value === 'desc');
+  };
+  var getOptions = function getOptions(customOptions) {
+    var order = 'asc';
+    var locale; // = 'en';
+    if (typeof customOptions === 'string' && isValidOrder(customOptions)) {
+      order = customOptions;
+    } else if (customOptions && typeof customOptions === 'object') {
+      if (customOptions.order && isValidOrder(customOptions.order)) {
+        order = customOptions.order;
+      }
+      if (customOptions.locale && customOptions.locale.length > 0) {
+        locale = customOptions.locale;
+      }
+    }
+    return {
+      order: order,
+      locale: locale
+    };
+  };
+
+  /**
+   * Creates a compare function that defines the natural sort order considering
+   * the given `options` which may be passed to [`Array.prototype.sort()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).
+   */
+  function compare(options) {
+    var validatedOptions = getOptions(options);
+    return baseCompare(validatedOptions);
+  }
+
+  var compareMultiple = function compareMultiple(recordA, recordB, orders, locale) {
+    var indexA = recordA.index,
+      valuesA = recordA.values;
+    var indexB = recordB.index,
+      valuesB = recordB.values;
+    var length = valuesA.length;
+    var ordersLength = orders.length;
+    for (var i = 0; i < length; i++) {
+      var order = i < ordersLength ? orders[i] : null;
+      if (order && typeof order === 'function') {
+        var result = order(valuesA[i].value, valuesB[i].value);
+        if (result) {
+          return result;
+        }
+      } else {
+        var _result = compareValues(valuesA[i], valuesB[i], locale);
+        if (_result) {
+          return _result * (order === 'desc' ? -1 : 1);
+        }
+      }
+    }
+    return indexA - indexB;
+  };
+
+  var createIdentifierFn = function createIdentifierFn(identifier) {
+    if (typeof identifier === 'function') {
+      // identifier is already a lookup function
+      return identifier;
+    }
+    return function (value) {
+      if (Array.isArray(value)) {
+        var index = Number(identifier);
+        if (Number.isInteger(index)) {
+          return value[index];
+        }
+      } else if (value && typeof value === 'object') {
+        var result = Object.getOwnPropertyDescriptor(value, identifier);
+        return result == null ? void 0 : result.value;
+      }
+      return value;
+    };
+  };
+
+  var getElementByIndex = function getElementByIndex(collection, index) {
+    return collection[index];
+  };
+
+  var getValueByIdentifier = function getValueByIdentifier(value, getValue) {
+    return getValue(value);
+  };
+
+  var baseOrderBy = function baseOrderBy(collection, identifiers, orders, locale) {
+    var identifierFns = identifiers.length ? identifiers.map(createIdentifierFn) : [function (value) {
+      return value;
+    }];
+
+    // temporary array holds elements with position and sort-values
+    var mappedCollection = collection.map(function (element, index) {
+      var values = identifierFns.map(function (identifier) {
+        return getValueByIdentifier(element, identifier);
+      }).map(getMappedValueRecord);
+      return {
+        index: index,
+        values: values
+      };
+    });
+
+    // iterate over values and compare values until a != b or last value reached
+    mappedCollection.sort(function (recordA, recordB) {
+      return compareMultiple(recordA, recordB, orders, locale);
+    });
+    return mappedCollection.map(function (element) {
+      return getElementByIndex(collection, element.index);
+    });
+  };
+
+  var getIdentifiers = function getIdentifiers(identifiers) {
+    if (!identifiers) {
+      return [];
+    }
+    var identifierList = !Array.isArray(identifiers) ? [identifiers] : [].concat(identifiers);
+    if (identifierList.some(function (identifier) {
+      return typeof identifier !== 'string' && typeof identifier !== 'number' && typeof identifier !== 'function';
+    })) {
+      return [];
+    }
+    return identifierList;
+  };
+
+  var getOrders = function getOrders(orders) {
+    if (!orders) {
+      return [];
+    }
+    var orderList = !Array.isArray(orders) ? [orders] : [].concat(orders);
+    if (orderList.some(function (order) {
+      return order !== 'asc' && order !== 'desc' && typeof order !== 'function';
+    })) {
+      return [];
+    }
+    return orderList;
+  };
+
+  /**
+   * Creates an array of elements, natural sorted by specified identifiers and
+   * the corresponding sort orders. This method implements a stable sort
+   * algorithm, which means the original sort order of equal elements is
+   * preserved.
+   */
+  function orderBy(collection, identifiers, orders, locale) {
+    if (!collection || !Array.isArray(collection)) {
+      return [];
+    }
+    var validatedIdentifiers = getIdentifiers(identifiers);
+    var validatedOrders = getOrders(orders);
+    return baseOrderBy(collection, validatedIdentifiers, validatedOrders, locale);
+  }
+
+  exports.compare = compare;
+  exports.orderBy = orderBy;
+
+}));

package/.output/server/node_modules/natural-orderby/dist/umd/natural-orderby.production.min.js

@@ -0,0 +1,11 @@
+/**
+ * natural-orderby v5.0.0
+ *
+ * Copyright (c) Olaf Ennen
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+!function(r,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((r="undefined"!=typeof globalThis?globalThis:r||self).naturalOrderBy={})}(this,(function(r){"use strict";var n=function(r,n){return r<n?-1:r>n?1:0},e=function(r,n,e){var t=r.localeCompare(n,e);return t?t/Math.abs(t):0},t=/(^0x[\da-fA-F]+$|^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?!\.\d+)(?=\D|\s|$))|\d+)/g,i=/^\s+|\s+$/g,o=/\s+/g,u=/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/,a=/(^([\w ]+,?[\w ]+)?[\w ]+,?[\w ]+\d+:\d+(:\d+)?[\w ]?|^\d{1,4}[/-]\d{1,4}[/-]\d{1,4}|^\w+, \w+ \d+, \d{4})/,s=/^0+[1-9]{1}[0-9]*$/,c=/[^\x00-\x80]/,f=function(r,n){return r<n?-1:r>n?1:0},l=function(r,t,i){return r.value===t.value?0:void 0!==r.parsedNumber&&void 0!==t.parsedNumber?n(r.parsedNumber,t.parsedNumber):r.chunks&&t.chunks?function(r,t,i){for(var o=r.length,u=t.length,a=Math.min(o,u),s=0;s<a;s++){var l=r[s],d=t[s];if(l.normalizedString!==d.normalizedString){if(""===l.normalizedString!=(""===d.normalizedString))return""===l.normalizedString?-1:1;if(void 0!==l.parsedNumber&&void 0!==d.parsedNumber){var m=n(l.parsedNumber,d.parsedNumber);return 0===m?f(l.normalizedString,d.normalizedString):m}return void 0!==l.parsedNumber||void 0!==d.parsedNumber?void 0!==l.parsedNumber?-1:1:c.test(l.normalizedString+d.normalizedString)?e(l.normalizedString,d.normalizedString,i):f(l.normalizedString,d.normalizedString)}}return o>a||u>a?o<=a?-1:1:0}(r.chunks,t.chunks,i):function(r,n){return(r.chunks?!n.chunks:n.chunks)?r.chunks?-1:1:(r.isNaN?!n.isNaN:n.isNaN)?r.isNaN?-1:1:(r.isSymbol?!n.isSymbol:n.isSymbol)?r.isSymbol?-1:1:(r.isObject?!n.isObject:n.isObject)?r.isObject?-1:1:(r.isArray?!n.isArray:n.isArray)?r.isArray?-1:1:(r.isFunction?!n.isFunction:n.isFunction)?r.isFunction?-1:1:(r.isNull?!n.isNull:n.isNull)?r.isNull?-1:1:0}(r,t)},d=function(r){return r.replace(o," ").replace(i,"")},m=function(r){if(0!==r.length){var n=Number(r.replace(/_/g,""));if(!Number.isNaN(n))return n}},p=function(r,n,e){if(u.test(r)&&(!s.test(r)||0===n||"."!==e[n-1]))return m(r)||0},y=function(r,n,e){return{parsedNumber:p(r,n,e),normalizedString:d(r)}},b=function(r){var n=function(r){return r.replace(t,"\0$1\0").replace(/\0$/,"").replace(/^\0/,"").split("\0")}(r).map(y);return n},N=function(r){return"function"==typeof r},v=function(r){return Number.isNaN(r)||r instanceof Number&&Number.isNaN(r.valueOf())},g=function(r){return null===r},S=function(r){return!(null===r||"object"!=typeof r||Array.isArray(r)||r instanceof Number||r instanceof String||r instanceof Boolean||r instanceof Date)},h=function(r){return"symbol"==typeof r},A=function(r){return void 0===r},z=function(r){var n=m(r);return void 0!==n?n:function(r){try{var n=Date.parse(r);return!Number.isNaN(n)&&a.test(r)?n:void 0}catch(r){return}}(r)},j=function(r){if("string"==typeof r||r instanceof String||("number"==typeof r||r instanceof Number)&&!v(r)||"boolean"==typeof r||r instanceof Boolean||r instanceof Date){var n=function(r){return"boolean"==typeof r||r instanceof Boolean?Number(r).toString():"number"==typeof r||r instanceof Number?r.toString():r instanceof Date?r.getTime().toString():"string"==typeof r||r instanceof String?r.toLowerCase().replace(i,""):""}(r),e=z(n);return{parsedNumber:e,chunks:b(e?""+e:n),value:r}}return{isArray:Array.isArray(r),isFunction:N(r),isNaN:v(r),isNull:g(r),isObject:S(r),isSymbol:h(r),isUndefined:A(r),value:r}},x=function(r){return"string"==typeof r&&("asc"===r||"desc"===r)};var k=function(r){return"function"==typeof r?r:function(n){if(Array.isArray(n)){var e=Number(r);if(Number.isInteger(e))return n[e]}else if(n&&"object"==typeof n){var t=Object.getOwnPropertyDescriptor(n,r);return null==t?void 0:t.value}return n}},w=function(r,n,e,t){var i=n.length?n.map(k):[function(r){return r}],o=r.map((function(r,n){return{index:n,values:i.map((function(n){return n(r)})).map(j)}}));return o.sort((function(r,n){return function(r,n,e,t){for(var i=r.index,o=r.values,u=n.index,a=n.values,s=o.length,c=e.length,f=0;f<s;f++){var d=f<c?e[f]:null;if(d&&"function"==typeof d){var m=d(o[f].value,a[f].value);if(m)return m}else{var p=l(o[f],a[f],t);if(p)return p*("desc"===d?-1:1)}}return i-u}(r,n,e,t)})),o.map((function(n){return function(r,n){return r[n]}(r,n.index)}))};r.compare=function(r){var n,e,t;return function(r){return function(n,e){var t=j(n),i=j(e);return l(t,i,r.locale)*("desc"===r.order?-1:1)}}((t="asc","string"==typeof(n=r)&&x(n)?t=n:n&&"object"==typeof n&&(n.order&&x(n.order)&&(t=n.order),n.locale&&n.locale.length>0&&(e=n.locale)),{order:t,locale:e}))},r.orderBy=function(r,n,e,t){if(!r||!Array.isArray(r))return[];var i=function(r){if(!r)return[];var n=Array.isArray(r)?[].concat(r):[r];return n.some((function(r){return"string"!=typeof r&&"number"!=typeof r&&"function"!=typeof r}))?[]:n}(n),o=function(r){if(!r)return[];var n=Array.isArray(r)?[].concat(r):[r];return n.some((function(r){return"asc"!==r&&"desc"!==r&&"function"!=typeof r}))?[]:n}(e);return w(r,i,o,t)}}));

package/.output/server/node_modules/natural-orderby/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "natural-orderby",
+  "version": "5.0.0",
+  "description": "Lightweight and performant natural sorting of arrays and collections by differentiating between unicode characters, numbers, dates, etc.",
+  "sideEffects": false,
+  "main": "./dist/main.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yobacca/natural-orderby.git"
+  },
+  "scripts": {
+    "build": "tsc && rollup -c",
+    "clean": "git clean -fdX .",
+    "docs": "docsify serve docs",
+    "format": "prettier --ignore-path .eslintignore --write src",
+    "lint": "eslint src",
+    "test": "cross-env TZ=UTC jest src",
+    "typecheck": "tsc --noEmit --emitDeclarationOnly false",
+    "size": "filesize",
+    "prepublishOnly": "yarn build",
+    "prepare": "husky"
+  },
+  "files": [
+    "dist/",
+    "LICENSE.md",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "keywords": [
+    "sort",
+    "order",
+    "string",
+    "natsort",
+    "natcmp",
+    "compare",
+    "alphanum",
+    "unicode",
+    "date",
+    "number",
+    "float",
+    "numeric",
+    "natural",
+    "human",
+    "javascript",
+    "array",
+    "collection",
+    "list",
+    "sorting",
+    "case sensitive",
+    "case insensitive",
+    "ascending",
+    "descending",
+    "browser",
+    "node.js",
+    "node"
+  ],
+  "author": "Olaf Ennen <olaf.ennen@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/yobacca/natural-orderby/issues"
+  },
+  "homepage": "https://yobacca.github.io/natural-orderby",
+  "dependencies": {},
+  "devDependencies": {
+    "@ampproject/filesize": "^4.3.0",
+    "@babel/core": "^7.18.2",
+    "@babel/preset-env": "^7.18.2",
+    "@babel/preset-modules": "^0.1.5",
+    "@babel/preset-typescript": "^7.17.12",
+    "@changesets/cli": "^2.25.2",
+    "@commitlint/cli": "^19.4.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@commitlint/types": "^19.0.3",
+    "@rollup/plugin-babel": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/jest": "29.5.13",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "cross-env": "^7.0.3",
+    "docsify-cli": "^4.3.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jest": "^28.8.0",
+    "eslint-plugin-n": "^17.10.2",
+    "eslint-plugin-prettier": "^5.2.1",
+    "husky": "^9.1.5",
+    "jest": "^29.3.1",
+    "lint-staged": "^15.2.9",
+    "prettier": "^3.3.3",
+    "rollup": "^4.21.1",
+    "rollup-plugin-delete": "^2.0.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "ts-jest": "^29.0.3",
+    "typescript": "^5.5.4"
+  },
+  "lint-staged": {
+    "*.{ts,md,json}": [
+      "prettier --write"
+    ],
+    "*.{ts,json}": [
+      "eslint --rule \"@typescript-eslint/no-unused-vars: error\""
+    ]
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "filesize": {
+    "./dist/umd/natural-orderby.production.min.js": {
+      "none": "5.5 kB"
+    },
+    "./dist/natural-orderby.production.min.js": {
+      "none": "4.6 kB"
+    }
+  }
+}

package/.output/server/node_modules/npm-run-path/index.js

@@ -0,0 +1,55 @@
+import process from 'node:process';
+import path from 'node:path';
+import pathKey from 'path-key';
+import {toPath, traversePathUp} from 'unicorn-magic';
+
+export const npmRunPath = ({
+	cwd = process.cwd(),
+	path: pathOption = process.env[pathKey()],
+	preferLocal = true,
+	execPath = process.execPath,
+	addExecPath = true,
+} = {}) => {
+	const cwdPath = path.resolve(toPath(cwd));
+	const result = [];
+	const pathParts = pathOption.split(path.delimiter);
+
+	if (preferLocal) {
+		applyPreferLocal(result, pathParts, cwdPath);
+	}
+
+	if (addExecPath) {
+		applyExecPath(result, pathParts, execPath, cwdPath);
+	}
+
+	return pathOption === '' || pathOption === path.delimiter
+		? `${result.join(path.delimiter)}${pathOption}`
+		: [...result, pathOption].join(path.delimiter);
+};
+
+const applyPreferLocal = (result, pathParts, cwdPath) => {
+	for (const directory of traversePathUp(cwdPath)) {
+		const pathPart = path.join(directory, 'node_modules/.bin');
+		if (!pathParts.includes(pathPart)) {
+			result.push(pathPart);
+		}
+	}
+};
+
+// Ensure the running `node` binary is used
+const applyExecPath = (result, pathParts, execPath, cwdPath) => {
+	const pathPart = path.resolve(cwdPath, toPath(execPath), '..');
+	if (!pathParts.includes(pathPart)) {
+		result.push(pathPart);
+	}
+};
+
+export const npmRunPathEnv = ({env = process.env, ...options} = {}) => {
+	env = {...env};
+
+	const pathName = pathKey({env});
+	options.path = env[pathName];
+	env[pathName] = npmRunPath(options);
+
+	return env;
+};