@rtorcato/js-common 3.0.0 → 5.0.0

package/dist/mime-types/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/mime-types/db.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0/Ib,CAAA;AAEV;;GAEG;AACH,MAAM,MAAM,aAAa,GACxB,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,iBAAiB,CAAA;AAErD,KAAK,cAAc,GAAG,MAAM,CAC3B,QAAQ,EACR;IACC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,OAAO,GAAG,IAAI,CAAA;CAC5B,CACD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAmC,cAAc,CAAA;AAEvE;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/mime-types/db.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAymHb,CAAA;AAEV;;GAEG;AACH,MAAM,MAAM,aAAa,GACxB,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,iBAAiB,CAAA;AAErD,KAAK,cAAc,GAAG,MAAM,CAC3B,QAAQ,EACR;IACC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,aAAa,EAAE,CAAA;CAC3B,CACD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAmC,cAAc,CAAA;AAEvE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAA"}

package/dist/mime-types/db.js

@@ -1 +1 @@
-import{a}from"../chunks/chunk-W72HFHZY.js";import"../chunks/chunk-ANN5UYCF.js";export{a as mimeTypes};
+import{a}from"../chunks/chunk-H7PB4TAW.js";import"../chunks/chunk-ANN5UYCF.js";export{a as mimeTypes};

package/dist/mime-types/index.js

@@ -1,4 +1,4 @@
-import{a as t}from"../chunks/chunk-W72HFHZY.js";import"../chunks/chunk-ANN5UYCF.js";function m(n){let e=n.lastIndexOf(".");return e<0?"":n.substring(e)}var p={},a={};u(p,a);function d(n){if(!n||typeof n!="string")return!1;let e=m(`x.${n}`).toLowerCase().substring(1);return e&&a[e]||!1}function u(n,e){let r=["nginx","apache",void 0,"iana"];for(let i of Object.keys(t)){let c=t[i],s=c.extensions;if(s?.length){n[i]=s;for(let o of s){if(e[o]){let f=r.indexOf(t[e[o]].source),x=r.indexOf(c.source);if(e[o]!=="application/octet-stream"&&(f>x||f===x&&e[o].startsWith("application/")))continue}e[o]=i}}}}export{p as extensions,d as lookup,t as mimeTypes,a as types};
+import{a as t}from"../chunks/chunk-H7PB4TAW.js";import"../chunks/chunk-ANN5UYCF.js";function m(n){let e=n.lastIndexOf(".");return e<0?"":n.substring(e)}var p={},a={};u(p,a);function d(n){if(!n||typeof n!="string")return!1;let e=m(`x.${n}`).toLowerCase().substring(1);return e&&a[e]||!1}function u(n,e){let r=["nginx","apache",void 0,"iana"];for(let i of Object.keys(t)){let c=t[i],s=c.extensions;if(s?.length){n[i]=s;for(let o of s){if(e[o]){let f=r.indexOf(t[e[o]].source),x=r.indexOf(c.source);if(e[o]!=="application/octet-stream"&&(f>x||f===x&&e[o].startsWith("application/")))continue}e[o]=i}}}}export{p as extensions,d as lookup,t as mimeTypes,a as types};
 /*!
  * mime-types
  * Copyright(c) 2014 Jonathan Ong

package/dist/numbers/index.d.ts

@@ -30,31 +30,40 @@ export declare function clamp(value: number, min: number, max: number): number;
  */
 export declare function roundTo(value: number, decimals?: number): number;
 /**
- * Checks if a value is a finite number.
- * @param value The value to check.
- * @returns True if the value is a finite number, false otherwise.
+ * Options for {@link formatPercent}.
  */
-export declare function isFiniteNumber(value: unknown): value is number;
+export interface FormatPercentOptions {
+    /** Number of decimal places (default: 0). */
+    fractionDigits?: number;
+    /**
+     * Force a leading `+` on positive values (e.g. `+2.14%`). Zero is never signed,
+     * regardless of this option, since `+0%` / `-0%` reads as noise — this is decided
+     * by the rounded, displayed value, so a value that rounds to zero at the given
+     * `fractionDigits` is unsigned too. Default: false.
+     */
+    signed?: boolean;
+}
 /**
  * Formats a number as a percentage string.
  *
+ * `value` is always treated as a fraction (0.25 → "25%"), matching the existing
+ * behaviour — it is not a pre-multiplied percentage (25 would format as "2500%").
+ *
  * @example
  * ```typescript
  * formatPercent(0.25) // '25%'
  * formatPercent(0.1234, 1) // '12.3%'
+ * formatPercent(0.0214, { fractionDigits: 2, signed: true }) // '+2.14%'
+ * formatPercent(-0.0088, { fractionDigits: 2, signed: true }) // '-0.88%'
+ * formatPercent(0, { signed: true }) // '0%' (zero is never signed)
+ * formatPercent(0.00001, { fractionDigits: 2, signed: true }) // '0.00%' (rounds to zero)
  * ```
  *
- * @param value The value to format (e.g. 0.25 for 25%).
- * @param fractionDigits Number of decimal places (default: 0).
+ * @param value The value to format, as a fraction (e.g. 0.25 for 25%).
+ * @param fractionDigitsOrOptions Number of decimal places (default: 0), or an options object.
  * @returns The formatted percentage string.
  */
-export declare function formatPercent(value: number, fractionDigits?: number): string;
-/**
- * Checks if a value is an integer.
- * @param value The value to check.
- * @returns True if the value is an integer, false otherwise.
- */
-export declare function isInteger(value: unknown): value is number;
+export declare function formatPercent(value: number, fractionDigitsOrOptions?: number | FormatPercentOptions): string;
 /**
  * Checks if a number is between two values.
  * @param value The number to check.
@@ -84,15 +93,75 @@ export declare function average(numbers: number[]): number;
  */
 export declare function mod(n: number, m: number): number;
 /**
- * Returns the smallest value in an array of numbers.
+ * Returns the variance of an array of numbers.
+ *
+ * Defaults to the **population** variance (divide by `n`). Pass
+ * `{ sample: true }` for the sample variance (Bessel's correction, `n - 1`) —
+ * the right choice when the values are a sample drawn from a larger population,
+ * such as a volatility estimate.
+ *
+ * @example
+ * ```typescript
+ * variance([2, 4, 4, 4, 5, 5, 7, 9]) // 4
+ * variance([2, 4, 4, 4, 5, 5, 7, 9], { sample: true }) // 4.571428...
+ * ```
+ *
+ * @param numbers The array of numbers.
+ * @param options `sample` divides by `n - 1` instead of `n`.
+ * @returns The variance, or 0 when there are too few values (empty array, or a
+ * single value with `sample: true`).
+ */
+export declare function variance(numbers: number[], options?: {
+    sample?: boolean;
+}): number;
+/**
+ * Returns the standard deviation of an array of numbers — the square root of
+ * {@link variance}, with the same population/sample choice.
+ *
+ * @example
+ * ```typescript
+ * stdDev([2, 4, 4, 4, 5, 5, 7, 9]) // 2
+ * stdDev([2, 4, 4, 4, 5, 5, 7, 9], { sample: true }) // 2.13808...
+ * ```
+ *
+ * @param numbers The array of numbers.
+ * @param options `sample` divides by `n - 1` instead of `n`.
+ * @returns The standard deviation, or 0 when there are too few values.
+ */
+export declare function stdDev(numbers: number[], options?: {
+    sample?: boolean;
+}): number;
+/**
+ * Returns the median of an array of numbers. Even-length inputs return the mean
+ * of the two middle values. The input array is not mutated.
+ *
+ * @example
+ * ```typescript
+ * median([3, 1, 2]) // 2
+ * median([4, 1, 3, 2]) // 2.5
+ * ```
+ *
  * @param numbers The array of numbers.
- * @returns The minimum value.
+ * @returns The median, or 0 if the array is empty.
  */
-export declare function min(numbers: number[]): number;
+export declare function median(numbers: number[]): number;
 /**
- * Returns the largest value in an array of numbers.
+ * Returns the `p`th percentile of an array of numbers using **linear
+ * interpolation between closest ranks** (the R-7 method, matching Excel's
+ * `PERCENTILE.INC` and NumPy's default): the value at position
+ * `(n - 1) * p / 100` in the sorted values, interpolated between neighbours.
+ * The input array is not mutated.
+ *
+ * @example
+ * ```typescript
+ * percentile([1, 2, 3, 4], 50) // 2.5
+ * percentile([1, 2, 3, 4], 25) // 1.75
+ * percentile([1, 2, 3, 4], 100) // 4
+ * ```
+ *
  * @param numbers The array of numbers.
- * @returns The maximum value.
+ * @param p The percentile to compute, 0–100 (clamped).
+ * @returns The percentile value, or 0 if the array is empty.
  */
-export declare function max(numbers: number[]): number;
+export declare function percentile(numbers: number[], p: number): number;
 //# sourceMappingURL=index.d.ts.map

package/dist/numbers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/numbers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAG3D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,SAAI,GAAG,MAAM,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,OAAO,CAE1F;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/numbers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAG3D;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,6CAA6C;IAC7C,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,MAAM,EACb,uBAAuB,CAAC,EAAE,MAAM,GAAG,oBAAoB,GACrD,MAAM,CAaR;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,OAAO,CAE1F;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,CAKtF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,CAEpF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAS/D"}

package/dist/numbers/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";function o(n,r,e){return Math.max(r,Math.min(e,n))}function m(n,r=2){let e=10**r;return Math.round(n*e)/e}function b(n){return typeof n=="number"&&Number.isFinite(n)}function i(n,r=0){return`${(n*100).toFixed(r)}%`}function c(n){return typeof n=="number"&&Number.isInteger(n)}function f(n,r,e,t=!0){return t?n>=r&&n<=e:n>r&&n<e}function u(n){return n.reduce((r,e)=>r+e,0)}function p(n){return n.length===0?0:u(n)/n.length}function x(n,r){return(n%r+r)%r}function a(n){return Math.min(...n)}function h(n){return Math.max(...n)}export{p as average,f as between,o as clamp,i as formatPercent,b as isFiniteNumber,c as isInteger,h as max,a as min,x as mod,m as roundTo,u as sum};
+import"../chunks/chunk-ANN5UYCF.js";function i(e,n,r){return Math.max(n,Math.min(r,e))}function l(e,n=2){let r=10**n;return Math.round(e*r)/r}function d(e,n){let{fractionDigits:r=0,signed:t=!1}=typeof n=="number"?{fractionDigits:n}:n??{},o=(e*100).toFixed(r);if(!t)return`${o}%`;let u=Number(o);return u===0?`${o.replace("-","")}%`:`${u>0?"+":""}${o}%`}function x(e,n,r,t=!0){return t?e>=n&&e<=r:e>n&&e<r}function m(e){return e.reduce((n,r)=>n+r,0)}function f(e){return e.length===0?0:m(e)/e.length}function h(e,n){return(e%n+n)%n}function p(e,n={}){let r=n.sample?e.length-1:e.length;if(r<=0)return 0;let t=f(e);return m(e.map(o=>(o-t)**2))/r}function g(e,n={}){return Math.sqrt(p(e,n))}function M(e){return s(e,50)}function s(e,n){if(e.length===0)return 0;let r=e.toSorted((b,a)=>b-a),t=(r.length-1)*i(n,0,100)/100,o=Math.floor(t),u=r[o],c=r[Math.ceil(t)];return u+(c-u)*(t-o)}export{f as average,x as between,i as clamp,d as formatPercent,M as median,h as mod,s as percentile,l as roundTo,g as stdDev,m as sum,p as variance};

package/dist/objects/index.d.ts

@@ -48,11 +48,4 @@ export declare function omit<T extends object, K extends keyof T>(obj: T, keys:
  * @returns {object}
  */
 export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
-/**
- * Deep clones a value using the native structuredClone algorithm.
- * Correctly handles Date, Map, Set, ArrayBuffer, and circular references.
- * @param obj The value to clone.
- * @returns A deep clone of the value.
- */
-export declare function deepClone<T>(obj: T): T;
 //# sourceMappingURL=index.d.ts.map

package/dist/objects/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/objects/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAEtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAUzF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAMvF;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAQvF;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAEtC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/objects/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAEtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAUzF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAMvF;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAQvF"}

package/dist/objects/index.js

@@ -1 +1 @@
-import{a,b,c,d,e}from"../chunks/chunk-ARW46OJS.js";import"../chunks/chunk-ANN5UYCF.js";export{e as deepClone,b as deepMerge,a as isPlainObject,c as omit,d as pick};
+import{a,b,c,d}from"../chunks/chunk-HUTZTT4Y.js";import"../chunks/chunk-ANN5UYCF.js";export{b as deepMerge,a as isPlainObject,c as omit,d as pick};

package/dist/objects/objects.test-d.js

@@ -1 +1 @@
-import{b as n,c,d as p,e as a}from"../chunks/chunk-ARW46OJS.js";import"../chunks/chunk-ANN5UYCF.js";import{describe as i,expectTypeOf as t,it as o}from"vitest";i("objects \u2014 types",()=>{o("pick narrows to the selected keys",()=>{let e=p({a:1,b:"two",c:!0},["a","c"]);t(e).toEqualTypeOf(),e.b}),o("omit drops the listed keys",()=>{let e=c({a:1,b:"two",c:!0},["b"]);t(e).toEqualTypeOf(),e.b}),o("deepMerge yields the intersection type",()=>{let b=n({x:1},{y:"two"});t(b).toEqualTypeOf()}),o("deepClone is identity over the input type",()=>{t(a({nested:{id:1}})).toEqualTypeOf()})});
+import{b as s,c as b,d as r}from"../chunks/chunk-HUTZTT4Y.js";import"../chunks/chunk-ANN5UYCF.js";import{describe as p,expectTypeOf as t,it as o}from"vitest";p("objects \u2014 types",()=>{o("pick narrows to the selected keys",()=>{let e=r({a:1,b:"two",c:!0},["a","c"]);t(e).toEqualTypeOf(),e.b}),o("omit drops the listed keys",()=>{let e=b({a:1,b:"two",c:!0},["b"]);t(e).toEqualTypeOf(),e.b}),o("deepMerge yields the intersection type",()=>{let n=s({x:1},{y:"two"});t(n).toEqualTypeOf()})});

package/dist/os/index.d.ts

@@ -1,14 +1,3 @@
-/**
- * Returns the current operating system platform (Node.js only).
- *
- * @example
- * ```typescript
- * getOsPlatform() // 'darwin' on macOS, 'win32' on Windows, undefined in a browser
- * ```
- *
- * @returns {string | undefined} The platform (e.g., 'darwin', 'win32', 'linux').
- */
-export declare function getOsPlatform(): string | undefined;
 /**
  * Returns the OS release/version (Node.js only).
  *

package/dist/os/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/os/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,CAGlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CAIjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAG9C;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,SAAS,CAM/C;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAO9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/os/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CAIjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAG9C;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,SAAS,CAM/C;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAO9C"}

package/dist/os/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";function e(){if(typeof process<"u"&&process.platform)return process.platform}function n(){if(typeof process<"u"&&process.release&&process.release.name)return process.release.name}function r(){if(typeof process<"u"&&process.arch)return process.arch}function s(){if(typeof process<"u"&&process.env&&process.env.HOME)return process.env.HOME;if(typeof process<"u"&&process.env&&process.env.USERPROFILE)return process.env.USERPROFILE}function o(){if(typeof process<"u"&&process.env&&process.env.TMPDIR)return process.env.TMPDIR;if(typeof process<"u"&&process.env&&process.env.TEMP)return process.env.TEMP;if(typeof process<"u"&&process.env&&process.env.TMP)return process.env.TMP}export{s as getHomeDir,r as getOsArch,e as getOsPlatform,n as getOsRelease,o as getTmpDir};
+import"../chunks/chunk-ANN5UYCF.js";function e(){if(typeof process<"u"&&process.release&&process.release.name)return process.release.name}function n(){if(typeof process<"u"&&process.arch)return process.arch}function r(){if(typeof process<"u"&&process.env&&process.env.HOME)return process.env.HOME;if(typeof process<"u"&&process.env&&process.env.USERPROFILE)return process.env.USERPROFILE}function s(){if(typeof process<"u"&&process.env&&process.env.TMPDIR)return process.env.TMPDIR;if(typeof process<"u"&&process.env&&process.env.TEMP)return process.env.TEMP;if(typeof process<"u"&&process.env&&process.env.TMP)return process.env.TMP}export{r as getHomeDir,n as getOsArch,e as getOsRelease,s as getTmpDir};

package/dist/promises/index.d.ts

@@ -1,17 +1,3 @@
-/**
- * Returns a promise that resolves after a given delay (ms).
- *
- * @example
- * ```typescript
- * const started = Date.now()
- * await delay(100)
- * Date.now() - started >= 100 // true
- * ```
- *
- * @param ms Milliseconds to wait.
- * @returns {Promise<void>}
- */
-export declare function delay(ms: number): Promise<void>;
 /**
  * Wraps a promise and returns a tuple [error, result].
  * The error slot is `unknown` — narrow it at the call site before touching its properties.
@@ -45,22 +31,55 @@ export declare function to<T>(promise: Promise<T>): Promise<[unknown, T | undefi
  * @returns {Promise<T>}
  */
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, error?: any): Promise<T>;
+/** Options for `retry`. Every field is optional. */
+export type RetryOptions = {
+    /** Retries after the first attempt, so `retries + 1` attempts in total. Default 3. */
+    retries?: number;
+    /** Base delay in ms; the cap doubles each retry (`minDelay * 2 ** (attempt - 1)`). Default 100. */
+    minDelay?: number;
+    /** Upper bound on a single wait, in ms. Default 10_000. */
+    maxDelay?: number;
+    /** Full jitter: wait a random 0..cap instead of the full cap. Default true. */
+    jitter?: boolean;
+    /** Return false to stop retrying and reject with `err`. Default: retry every error. */
+    shouldRetry?: (err: unknown, attempt: number) => boolean;
+    /** Stops further attempts and aborts the wait; the promise rejects with `signal.reason`. */
+    signal?: AbortSignal;
+};
 /**
- * Returns a promise that resolves when all promises resolve, or rejects on the first rejection (like Promise.all).
- * @param promises Array of promises.
- * @returns {Promise<T[]>}
- */
-export declare function all<T>(promises: Promise<T>[]): Promise<T[]>;
-/**
- * Returns a promise that resolves when all promises settle (like Promise.allSettled).
- * @param promises Array of promises.
- * @returns {Promise<PromiseSettledResult<T>[]>}
+ * Runs `fn` until it resolves, retrying rejections with exponential backoff and full jitter.
+ * `attempt` is 1-based. Rejects with the last error once retries run out or `shouldRetry`
+ * says no, or with `signal.reason` if the signal aborts.
+ *
+ * @example
+ * ```typescript
+ * const report = await retry((attempt, signal) => fetch('/api/report', { signal }), {
+ *   retries: 4,
+ *   shouldRetry: (err) => !(err instanceof HttpError) || err.status >= 500,
+ *   signal: AbortSignal.timeout(30_000),
+ * })
+ * ```
+ *
+ * @param fn The operation to run; receives the attempt number and the caller's signal.
+ * @param opts Retry count, backoff bounds, jitter, retry predicate and abort signal.
+ * @returns {Promise<T>}
  */
-export declare function allSettled<T>(promises: Promise<T>[]): Promise<PromiseSettledResult<T>[]>;
+export declare function retry<T>(fn: (attempt: number, signal?: AbortSignal) => Promise<T>, opts?: RetryOptions): Promise<T>;
 /**
- * Returns a promise that resolves or rejects as soon as one of the promises resolves or rejects (like Promise.race).
- * @param promises Array of promises.
- * @returns {Promise<T>}
+ * Maps `items` through an async `fn` with at most `limit` calls in flight, resolving to the
+ * results in input order. On the first rejection no new calls are started and the returned
+ * promise rejects with that error, like `Promise.all`; calls already in flight are not cancelled.
+ *
+ * @example
+ * ```typescript
+ * const users = await mapLimit(ids, 4, (id) => getUser(id))
+ * ```
+ *
+ * @param items The values to map.
+ * @param limit Maximum number of concurrent calls — a positive integer.
+ * @param fn Async mapper, called with each item and its index.
+ * @returns {Promise<R[]>}
+ * @throws {RangeError} If `limit` is not a positive integer (the promise rejects).
  */
-export declare function race<T>(promises: Promise<T>[]): Promise<T>;
+export declare function mapLimit<T, R>(items: Iterable<T>, limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
 //# sourceMappingURL=index.d.ts.map

package/dist/promises/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/promises/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAOlF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC5B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,GAA0B,GAC/B,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,CAExF;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAE1D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/promises/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAOlF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC5B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,GAA0B,GAC/B,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG;IAC1B,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uFAAuF;IACvF,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAA;IACxD,4FAA4F;IAC5F,MAAM,CAAC,EAAE,WAAW,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC5B,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EACzD,IAAI,GAAE,YAAiB,GACrB,OAAO,CAAC,CAAC,CAAC,CAoBZ;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GACxC,OAAO,CAAC,CAAC,EAAE,CAAC,CAqBd"}

package/dist/promises/index.js

@@ -1 +1 @@
-import{a,b,c,d,e,f}from"../chunks/chunk-7JQSIREC.js";import"../chunks/chunk-ANN5UYCF.js";export{d as all,e as allSettled,a as delay,f as race,b as to,c as withTimeout};
+import{a,b,c,d}from"../chunks/chunk-NEODDZIS.js";import"../chunks/chunk-VSTXGIC3.js";import"../chunks/chunk-ANN5UYCF.js";export{d as mapLimit,c as retry,a as to,b as withTimeout};

package/dist/promises/promises.test-d.js

@@ -1 +1 @@
-import{b as t,c as r,d as i,e as s,f as l}from"../chunks/chunk-7JQSIREC.js";import"../chunks/chunk-ANN5UYCF.js";import{describe as m,expectTypeOf as e,it as o}from"vitest";m("promises \u2014 types",()=>{o("withTimeout preserves the awaited type",()=>{e(r(Promise.resolve(42),10)).toEqualTypeOf(),e(r(Promise.resolve({id:1}),10)).toEqualTypeOf()}),o("to returns an [error, value] tuple with the value widened to undefined",()=>{e(t(Promise.resolve("x"))).toEqualTypeOf()}),o("all/allSettled/race preserve the element type",()=>{e(i([Promise.resolve(1)])).toEqualTypeOf(),e(s([Promise.resolve("a")])).toEqualTypeOf(),e(l([Promise.resolve(!0)])).toEqualTypeOf()})});
+import{a as o,b as e}from"../chunks/chunk-NEODDZIS.js";import"../chunks/chunk-VSTXGIC3.js";import"../chunks/chunk-ANN5UYCF.js";import{describe as t,expectTypeOf as r,it as i}from"vitest";t("promises \u2014 types",()=>{i("withTimeout preserves the awaited type",()=>{r(e(Promise.resolve(42),10)).toEqualTypeOf(),r(e(Promise.resolve({id:1}),10)).toEqualTypeOf()}),i("to returns an [error, value] tuple with the value widened to undefined",()=>{r(o(Promise.resolve("x"))).toEqualTypeOf()})});

package/dist/regex/index.d.ts

@@ -1,6 +1,13 @@
 /**
  * Escapes special regex characters in a string so it can be used in a RegExp.
  *
+ * The output is safe with or without the `u` flag, inside a character class, and
+ * inside a regex literal: `/` is escaped, and `-` becomes `\x2d` because `\-` is a
+ * syntax error outside a class in `u` mode.
+ *
+ * Native `RegExp.escape` (Node 24+) is the eventual replacement once the engine
+ * floor reaches it.
+ *
  * @example
  * ```typescript
  * escapeRegExp('1 + 1 = 2?') // '1 \\+ 1 = 2\\?'

package/dist/regex/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/regex/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAGxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,EAAE,CASlF;AAED;;;;;;GAMG;AAEH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,WAAW,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC,GACnE,MAAM,CASR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAG5E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/regex/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAGxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,EAAE,CASlF;AAED;;;;;;GAMG;AAEH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,WAAW,EAAE,MAAM,GAAG,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC,GACnE,MAAM,CASR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAG5E"}

package/dist/regex/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";function n(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function i(e,g){return(typeof g=="string"?new RegExp(g):g).test(e)}function x(e,g){let s=typeof g=="string"?new RegExp(g,"g"):new RegExp(g.source,g.flags.includes("g")?g.flags:`${g.flags}g`);return Array.from(e.matchAll(s))}function t(e,g,s){let r=typeof g=="string"?new RegExp(g,"g"):new RegExp(g.source,g.flags.includes("g")?g.flags:`${g.flags}g`);return e.replace(r,s)}function o(e,g){let s=typeof g=="string"?new RegExp(g):g;return e.split(s)}export{n as escapeRegExp,x as matchAll,t as replaceAllRegex,o as splitByRegex,i as testRegex};
+import"../chunks/chunk-ANN5UYCF.js";function n(e){return e.replace(/[.*+?^${}()|[\]\\/]/g,"\\$&").replace(/-/g,"\\x2d")}function i(e,g){return(typeof g=="string"?new RegExp(g):g).test(e)}function x(e,g){let s=typeof g=="string"?new RegExp(g,"g"):new RegExp(g.source,g.flags.includes("g")?g.flags:`${g.flags}g`);return Array.from(e.matchAll(s))}function t(e,g,s){let r=typeof g=="string"?new RegExp(g,"g"):new RegExp(g.source,g.flags.includes("g")?g.flags:`${g.flags}g`);return e.replace(r,s)}function o(e,g){let s=typeof g=="string"?new RegExp(g):g;return e.split(s)}export{n as escapeRegExp,x as matchAll,t as replaceAllRegex,o as splitByRegex,i as testRegex};

package/dist/security/index.d.ts

@@ -35,17 +35,4 @@ export declare function stripScriptish(str: string): string;
  * @returns True if the password is strong, false otherwise.
  */
 export declare function isStrongPassword(password: string): boolean;
-/**
- * Generates a cryptographically secure random token (hex string).
- *
- * @example
- * ```typescript
- * generateSecureToken() // 64 hex chars (32 bytes)
- * generateSecureToken(8) // 'c1f0a4e29b73d518'
- * ```
- *
- * @param length The number of bytes (not hex chars).
- * @returns A random hex string.
- */
-export declare function generateSecureToken(length?: number): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/security/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/security/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgBlD;AAgDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAI1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAK,GAAG,MAAM,CAEvD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/security/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgBlD;AAgDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAI1D"}

package/dist/security/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";import{randomBytes as a}from"node:crypto";function u(t){let e=d(t),n;do n=e,e=e.replace(/[\s/]on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]*)/gi,"");while(e!==n);return e}function d(t){let e=t.toLowerCase(),n="",i=0,s=0;for(;;){let r=e.indexOf("<script",s);if(r===-1)break;let o=e[r+7];if(o!==void 0&&o!==">"&&o!=="/"&&!/\s/.test(o)){s=r+7;continue}let c=e.indexOf(">",r);if(c===-1)break;let f=e.indexOf("</script",c);if(f===-1)break;let l=e.indexOf(">",f);if(l===-1)break;n+=t.slice(i,r),i=l+1,s=i}return n+t.slice(i)}function g(t){return/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]).{8,}$/.test(t)}function x(t=32){return a(t).toString("hex")}export{x as generateSecureToken,g as isStrongPassword,u as stripScriptish};
+import"../chunks/chunk-ANN5UYCF.js";function a(t){let e=d(t),n;do n=e,e=e.replace(/[\s/]on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]*)/gi,"");while(e!==n);return e}function d(t){let e=t.toLowerCase(),n="",s=0,r=0;for(;;){let i=e.indexOf("<script",r);if(i===-1)break;let o=e[i+7];if(o!==void 0&&o!==">"&&o!=="/"&&!/\s/.test(o)){r=i+7;continue}let c=e.indexOf(">",i);if(c===-1)break;let f=e.indexOf("</script",c);if(f===-1)break;let l=e.indexOf(">",f);if(l===-1)break;n+=t.slice(s,i),s=l+1,r=s}return n+t.slice(s)}function p(t){return/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]).{8,}$/.test(t)}export{p as isStrongPassword,a as stripScriptish};

package/dist/sleep/index.d.ts

@@ -38,10 +38,11 @@ export declare function sleepSync(ms: number): void;
  */
 export declare function sleepRandom(min: number, max: number): Promise<void>;
 /**
- * Returns a promise that resolves after ms, or rejects if aborted via AbortSignal.
+ * Returns a promise that resolves after ms, or rejects with `signal.reason` if aborted.
+ * An already-aborted signal rejects immediately.
  * @param ms Milliseconds to sleep.
  * @param signal Optional AbortSignal to cancel the sleep.
- * @returns Promise that resolves after ms or rejects if aborted.
+ * @returns Promise that resolves after ms or rejects with `signal.reason` if aborted.
  */
 export declare function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/sleep/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sleep/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CACG,CAAA;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAG1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sleep/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CACG,CAAA;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAG1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB9E"}

package/dist/sleep/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";var i=e=>new Promise(o=>setTimeout(o,e));function m(e){let o=Date.now()+e;for(;Date.now()<o;);}function s(e,o){let t=Math.floor(Math.random()*(o-e+1))+e;return new Promise(r=>setTimeout(r,t))}function u(e,o){return new Promise((t,r)=>{let n=setTimeout(t,e);o&&o.addEventListener("abort",()=>{clearTimeout(n),r(new Error("Sleep aborted"))})})}export{i as sleep,s as sleepRandom,m as sleepSync,u as sleepWithAbort};
+import{a,b,c,d}from"../chunks/chunk-VSTXGIC3.js";import"../chunks/chunk-ANN5UYCF.js";export{a as sleep,c as sleepRandom,b as sleepSync,d as sleepWithAbort};

package/dist/strings/index.d.ts

@@ -74,36 +74,14 @@ export declare function kebabCase(str: string): string;
 export declare function snakeCase(str: string): string;
 /**
  * Truncates a string to a maximum length, adding ellipsis if needed.
+ * Length is counted in graphemes, so emoji and combining marks are never split.
  * @param str The string to truncate.
- * @param maxLength The maximum length.
+ * @param maxLength The maximum length in graphemes, ellipsis included. `<= 0` returns `''`.
  * @returns The truncated string.
  */
 export declare function truncate(str: string, maxLength: number): string;
 /**
- * Pads the start of a string to a given length.
- * @param str The string to pad.
- * @param targetLength The target length.
- * @param padString The string to pad with.
- * @returns The padded string.
- */
-export declare function padStart(str: string, targetLength: number, padString?: string): string;
-/**
- * Pads the end of a string to a given length.
- * @param str The string to pad.
- * @param targetLength The target length.
- * @param padString The string to pad with.
- * @returns The padded string.
- */
-export declare function padEnd(str: string, targetLength: number, padString?: string): string;
-/**
- * replace all items in a string using regex
- * @param  {string} str
- * @param  {string} search
- * @param  {string} replacement
- */
-export declare const replaceString: (str: string, search: string, replacement: string) => string;
-/**
- * Reverses a string.
+ * Reverses a string by grapheme, so emoji sequences, flags and combining marks stay intact.
  *
  * @example
  * ```typescript

package/dist/strings/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/strings/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAEnF;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAEjF;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,EAAE,aAAa,MAAM,KAAG,MAEhF,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAO3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAmB9C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,MAAM,CAOhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAI3E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/strings/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK7C;AAQD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAI/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAO3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAmB9C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,MAAM,CAOhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAI3E"}

package/dist/strings/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";function s(r){return r.replace(/\w\S*/g,e=>e.charAt(0).toUpperCase()+e.slice(1).toLowerCase())}function o(r){return r.length===0?"":(r[0]?.toUpperCase()??"")+r.slice(1)}function g(r){return r.replace(/[-_\s]+(.)?/g,(e,t)=>t?t.toUpperCase():"").replace(/^(.)/,e=>e.toLowerCase())}function a(r){return r.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[_\s]+/g,"-").toLowerCase()}function c(r){return r.replace(/([a-z])([A-Z])/g,"$1_$2").replace(/[-\s]+/g,"_").toLowerCase()}function u(r,e){return r.length>e?`${r.slice(0,e-1)}\u2026`:r}function p(r,e,t=" "){return r.padStart(e,t)}function l(r,e,t=" "){return r.padEnd(e,t)}var f=(r,e,t)=>r.replace(new RegExp(e,"g"),t);function x(r){return[...r].reverse().join("")}function $(r){return r.normalize("NFD").replace(/[\u0300-\u036f]/g,"").toLowerCase().trim().replace(/[^a-z0-9\s-]/g,"").replace(/[\s_]+/g,"-").replace(/-+/g,"-").replace(/^-|-$/g,"")}function b(r){return r.replace(/([a-z])([A-Z])/g,"$1 $2").replace(/[-_]+/g," ").trim().split(/\s+/).filter(Boolean)}function m(r){let e=r.trim();return e===""?0:e.split(/\s+/).length}function w(r,e,t){return e===1?r:t??`${r}s`}function C(r){let e=Math.abs(r),t=e%100,n=e%10;if(t>=11&&t<=13)return`${r}th`;switch(n){case 1:return`${r}st`;case 2:return`${r}nd`;case 3:return`${r}rd`;default:return`${r}th`}}function h(r){return r.trim().length===0}function d(r,e,t,n="*"){if(e<0&&(e=0),t>r.length&&(t=r.length),e>=t)return r;let i=n.repeat(t-e);return r.slice(0,e)+i+r.slice(t)}function z(r,e){return r.replace(/\$\{(\w+)\}/g,(t,n)=>Object.hasOwn(e,n)?String(e[n]):t)}export{g as camelCase,o as capitalize,h as isBlank,a as kebabCase,d as mask,C as ordinalize,l as padEnd,p as padStart,w as pluralize,f as replaceString,x as reverse,$ as slugify,c as snakeCase,z as template,s as titleCase,u as truncate,m as wordCount,b as words};
+import"../chunks/chunk-ANN5UYCF.js";function g(e){return e.replace(/\w\S*/g,r=>r.charAt(0).toUpperCase()+r.slice(1).toLowerCase())}function a(e){return e.length===0?"":(e[0]?.toUpperCase()??"")+e.slice(1)}function c(e){return e.replace(/[-_\s]+(.)?/g,(r,t)=>t?t.toUpperCase():"").replace(/^(.)/,r=>r.toLowerCase())}function u(e){return e.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[_\s]+/g,"-").toLowerCase()}function l(e){return e.replace(/([a-z])([A-Z])/g,"$1_$2").replace(/[-\s]+/g,"_").toLowerCase()}var o=new Intl.Segmenter(void 0,{granularity:"grapheme"});function i(e){return Array.from(o.segment(e),r=>r.segment)}function p(e,r){if(r<=0)return"";let t=i(e);return t.length>r?`${t.slice(0,r-1).join("")}\u2026`:e}function f(e){return i(e).reverse().join("")}function m(e){return e.normalize("NFD").replace(/[\u0300-\u036f]/g,"").toLowerCase().trim().replace(/[^a-z0-9\s-]/g,"").replace(/[\s_]+/g,"-").replace(/-+/g,"-").replace(/^-|-$/g,"")}function $(e){return e.replace(/([a-z])([A-Z])/g,"$1 $2").replace(/[-_]+/g," ").trim().split(/\s+/).filter(Boolean)}function h(e){let r=e.trim();return r===""?0:r.split(/\s+/).length}function w(e,r,t){return r===1?e:t??`${e}s`}function C(e){let r=Math.abs(e),t=r%100,n=r%10;if(t>=11&&t<=13)return`${e}th`;switch(n){case 1:return`${e}st`;case 2:return`${e}nd`;case 3:return`${e}rd`;default:return`${e}th`}}function b(e){return e.trim().length===0}function x(e,r,t,n="*"){if(r<0&&(r=0),t>e.length&&(t=e.length),r>=t)return e;let s=n.repeat(t-r);return e.slice(0,r)+s+e.slice(t)}function z(e,r){return e.replace(/\$\{(\w+)\}/g,(t,n)=>Object.hasOwn(r,n)?String(r[n]):t)}export{c as camelCase,a as capitalize,b as isBlank,u as kebabCase,x as mask,C as ordinalize,w as pluralize,f as reverse,m as slugify,l as snakeCase,z as template,g as titleCase,p as truncate,h as wordCount,$ as words};

package/dist/system/index.d.ts

@@ -1,6 +1,10 @@
 /**
  * Checks if the current OS is macOS.
  *
+ * The user-agent branch is deprecated — browser detection belongs to
+ * `@rtorcato/browser-common` and will be removed in the next major. In Node this
+ * reads `process.platform` and stays.
+ *
  * @example
  * ```typescript
  * isMacOs() // true on macOS (via process.platform in Node, userAgent in the browser)
@@ -12,6 +16,10 @@ export declare function isMacOs(): boolean;
 /**
  * Checks if the current OS is Windows.
  *
+ * The user-agent branch is deprecated — browser detection belongs to
+ * `@rtorcato/browser-common` and will be removed in the next major. In Node this
+ * reads `process.platform` and stays.
+ *
  * @example
  * ```typescript
  * isWindows() // true when process.platform === 'win32'
@@ -23,6 +31,10 @@ export declare function isWindows(): boolean;
 /**
  * Checks if the current OS is Linux.
  *
+ * The user-agent branch is deprecated — browser detection belongs to
+ * `@rtorcato/browser-common` and will be removed in the next major. In Node this
+ * reads `process.platform` and stays.
+ *
  * @example
  * ```typescript
  * isLinux() // true when process.platform === 'linux'
@@ -32,22 +44,29 @@ export declare function isWindows(): boolean;
  */
 export declare function isLinux(): boolean;
 /**
- * Checks if the device is running iOS.
+ * Checks if the device is running iOS. Always `false` in Node.
+ * @deprecated Browser detection belongs to `@rtorcato/browser-common`; removed in the next major.
  * @returns {boolean} True if iOS, false otherwise.
  */
 export declare function isIOS(): boolean;
 /**
- * Checks if the device is running Android.
+ * Checks if the device is running Android. Always `false` in Node.
+ * @deprecated Browser detection belongs to `@rtorcato/browser-common`; removed in the next major.
  * @returns {boolean} True if Android, false otherwise.
  */
 export declare function isAndroid(): boolean;
 /**
  * Returns a string representing the detected platform.
+ *
+ * The user-agent branch is deprecated — browser detection belongs to
+ * `@rtorcato/browser-common` and will be removed in the next major. In Node this
+ * reads `process.platform` and stays.
  * @returns {string} The platform name (e.g., 'macos', 'windows', 'linux', 'ios', 'android', or 'unknown').
  */
 export declare function getPlatform(): string;
 /**
- * Checks if the device supports touch events.
+ * Checks if the device supports touch events. Always `false` in Node.
+ * @deprecated Browser detection belongs to `@rtorcato/browser-common`; removed in the next major.
  * @returns {boolean} True if touch is supported, false otherwise.
  */
 export declare function isTouchDevice(): boolean;

package/dist/system/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAQjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAQnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAQjC;AAED;;;GAGG;AACH,wBAAgB,KAAK,IAAI,OAAO,CAK/B;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAOpC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAMvC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAUjC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAQnC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,IAAI,OAAO,CASjC;AAED;;;;GAIG;AACH,wBAAgB,KAAK,IAAI,OAAO,CAK/B;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAQpC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAMvC"}

package/dist/system/index.js

@@ -1 +1 @@
-import"../chunks/chunk-ANN5UYCF.js";function n(){return typeof window<"u"?window.navigator.userAgent.includes("Mac"):typeof process<"u"&&process.platform?process.platform==="darwin":!1}function e(){return typeof window<"u"?window.navigator.userAgent.includes("Windows"):typeof process<"u"&&process.platform?process.platform==="win32":!1}function o(){return typeof window<"u"?window.navigator.userAgent.includes("Linux"):typeof process<"u"&&process.platform?process.platform==="linux":!1}function r(){return typeof window<"u"?/iPad|iPhone|iPod/.test(window.navigator.userAgent)&&!window.MSStream:!1}function i(){return typeof window<"u"?window.navigator.userAgent.includes("Android"):!1}function t(){return n()?"macos":e()?"windows":o()?"linux":r()?"ios":i()?"android":"unknown"}function u(){return typeof window>"u"?!1:"ontouchstart"in window||typeof navigator.maxTouchPoints=="number"&&navigator.maxTouchPoints>0}export{t as getPlatform,i as isAndroid,r as isIOS,o as isLinux,n as isMacOs,u as isTouchDevice,e as isWindows};
+import"../chunks/chunk-ANN5UYCF.js";var e=/iPad|iPhone|iPod/;function o(){if(typeof window<"u"){let n=window.navigator.userAgent;return n.includes("Mac")&&!e.test(n)}return typeof process<"u"&&process.platform?process.platform==="darwin":!1}function r(){return typeof window<"u"?window.navigator.userAgent.includes("Windows"):typeof process<"u"&&process.platform?process.platform==="win32":!1}function i(){if(typeof window<"u"){let n=window.navigator.userAgent;return n.includes("Linux")&&!n.includes("Android")}return typeof process<"u"&&process.platform?process.platform==="linux":!1}function t(){return typeof window<"u"?e.test(window.navigator.userAgent)&&!window.MSStream:!1}function u(){return typeof window<"u"?window.navigator.userAgent.includes("Android"):!1}function s(){return t()?"ios":u()?"android":o()?"macos":r()?"windows":i()?"linux":"unknown"}function f(){return typeof window>"u"?!1:"ontouchstart"in window||typeof navigator.maxTouchPoints=="number"&&navigator.maxTouchPoints>0}export{s as getPlatform,u as isAndroid,t as isIOS,i as isLinux,o as isMacOs,f as isTouchDevice,r as isWindows};