@glion/util-semver 0.14.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Rethink Health
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,379 @@
+# @glion/util-semver
+
+A tiny, fast, and secure version utility for HL7v2-like version strings. Intentionally simplified for our ecosystem while maintaining excellent performance and type safety.
+
+## Features
+
+✨ **Simple & Elegant** - Clean API, no unnecessary complexity
+⚡ **High Performance** - O(n) algorithms, Range caching for hot paths
+🔒 **Secure** - ReDoS protection, integer overflow guards
+📘 **Type Safe** - Full TypeScript support with structured errors
+🪶 **Tiny** - ~6KB, zero dependencies
+
+## Installation
+
+```bash
+npm install @glion/util-semver
+```
+
+## Quick Start
+
+```typescript
+import {
+  parse,
+  clean,
+  compare,
+  satisfies,
+  sort,
+  maxSatisfying,
+  increment,
+  diff,
+  Range,
+} from "@glion/util-semver";
+
+// Parse versions
+parse("2.3"); // { major: 2, minor: 3, patch: 0 }
+clean("2"); // "2.0.0"
+valid("2.5.1"); // true
+
+// Compare versions
+compare("2.3.1", "2.4"); // -1 (less than)
+eq("2.5.0", "2.5"); // true
+gt("2.5.1", "2.5.0"); // true
+
+// Version ranges
+satisfies("2.5.1", ">=2.0 <3.0"); // true
+satisfies("2.5.1", "2.5.1"); // true (exact match)
+
+// Collection operations
+sort(["2.5", "2.3.1", "2.10"]); // ["2.3.1", "2.5", "2.10"]
+maxSatisfying(["2.3", "2.5", "3.0"], ">=2.0 <3.0"); // "2.5"
+minSatisfying(["2.3", "2.5", "3.0"], ">=2.0 <3.0"); // "2.3"
+
+// Version manipulation
+increment("2.5.1", "minor"); // "2.6.0"
+diff("2.5.1", "2.6.0"); // "minor"
+```
+
+## API Reference
+
+### Parsing & Validation
+
+#### `parse(version: string): Hl7Version`
+
+Parses a version string into a structured object.
+
+```typescript
+parse("2.5.1"); // { major: 2, minor: 5, patch: 1 }
+parse("2.3"); // { major: 2, minor: 3, patch: 0 }
+parse("2"); // { major: 2, minor: 0, patch: 0 }
+```
+
+**Throws:** `VersionParseError` if invalid format
+
+#### `clean(version: string): string`
+
+Converts a version to canonical format (major.minor.patch).
+
+```typescript
+clean("2"); // "2.0.0"
+clean("2.5"); // "2.5.0"
+clean(" 2.5 "); // "2.5.0"
+```
+
+**Throws:** `VersionParseError` if invalid format
+
+#### `valid(version: string): boolean`
+
+Checks if a string is a valid version. Never throws.
+
+```typescript
+valid("2.5.1"); // true
+valid("2"); // true
+valid("HELLO"); // false
+```
+
+### Comparison
+
+#### `compare(a, b): -1 | 0 | 1`
+
+Compares two versions.
+
+```typescript
+compare("2.3.1", "2.4"); // -1 (a < b)
+compare("2.5.1", "2.5.1"); // 0  (a = b)
+compare("2.6", "2.5.9"); // 1  (a > b)
+```
+
+#### Comparison Operators
+
+- `eq(a, b)` - Equal to
+- `lt(a, b)` - Less than
+- `lte(a, b)` - Less than or equal
+- `gt(a, b)` - Greater than
+- `gte(a, b)` - Greater than or equal
+
+```typescript
+eq("2.5.0", "2.5"); // true
+lt("2.3", "2.4"); // true
+gte("2.5.1", "2.5"); // true
+```
+
+### Range Matching
+
+#### `satisfies(version, range): boolean`
+
+Checks if a version satisfies a range expression.
+
+**Range Syntax:**
+
+- Operators: `=`, `<`, `<=`, `>`, `>=`
+- Multiple comparators: Space-separated (AND logic)
+- Default operator: `=` (exact match)
+
+```typescript
+satisfies("2.5.1", ">=2.0 <3.0"); // true
+satisfies("2.5.1", "2.5.1"); // true (exact match)
+satisfies("2.5.1", ">=2.6"); // false
+```
+
+**Performance Tip:** Use `Range` objects for repeated checks:
+
+```typescript
+// Slow: Parse range every time
+for (const version of versions) {
+  if (satisfies(version, ">=2.0 <3.0")) {
+    /* ... */
+  }
+}
+
+// Fast: Parse once, reuse many times
+const range = new Range(">=2.0 <3.0");
+for (const version of versions) {
+  if (satisfies(version, range)) {
+    /* ... */
+  }
+}
+```
+
+#### `Range` Class
+
+Pre-parsed range for efficient reuse.
+
+```typescript
+const range = new Range(">=2.0 <3.0");
+range.test("2.5.1"); // true
+range.test("3.0.0"); // false
+
+// Works with all range functions
+satisfies("2.5.1", range);
+maxSatisfying(versions, range);
+minSatisfying(versions, range);
+```
+
+### Collection Operations
+
+#### `sort(versions: string[]): string[]`
+
+Sorts versions in ascending order. Returns new array (does not mutate).
+
+```typescript
+sort(["2.5", "2.3.1", "2.10.0"]);
+// => ["2.3.1", "2.5", "2.10.0"]
+```
+
+#### `maxSatisfying(versions, range): string | null`
+
+Finds the highest version that satisfies a range.
+
+```typescript
+maxSatisfying(["2.3.0", "2.5.1", "3.0.0"], ">=2.0 <3.0");
+// => "2.5.1"
+
+maxSatisfying(["2.3.0", "2.5.1"], ">=3.0");
+// => null (no matches)
+```
+
+#### `minSatisfying(versions, range): string | null`
+
+Finds the lowest version that satisfies a range.
+
+```typescript
+minSatisfying(["2.3.0", "2.5.1", "3.0.0"], ">=2.0 <3.0");
+// => "2.3.0"
+```
+
+### Version Manipulation
+
+#### `increment(version, release): string`
+
+Increments a version component. Lower components reset to zero.
+
+```typescript
+increment("2.5.1", "major"); // "3.0.0"
+increment("2.5.1", "minor"); // "2.6.0"
+increment("2.5.1", "patch"); // "2.5.2"
+```
+
+#### `diff(v1, v2): 'major' | 'minor' | 'patch' | null`
+
+Determines which component differs between versions.
+
+```typescript
+diff("2.5.1", "3.0.0"); // "major"
+diff("2.5.1", "2.6.0"); // "minor"
+diff("2.5.1", "2.5.2"); // "patch"
+diff("2.5.1", "2.5.1"); // null (equal)
+```
+
+## Error Handling
+
+All parsing/operation functions throw structured errors for invalid input:
+
+```typescript
+import { VersionParseError, RangeParseError } from "@glion/util-semver";
+
+try {
+  parse("INVALID");
+} catch (e) {
+  if (e instanceof VersionParseError) {
+    console.log(e.input); // "INVALID"
+    console.log(e.reason); // "expected format: major.minor.patch..."
+    console.log(e.message); // Full formatted message
+  }
+}
+
+try {
+  satisfies("2.5.1", "INVALID_RANGE");
+} catch (e) {
+  if (e instanceof RangeParseError) {
+    console.log(e.token); // "INVALID_RANGE"
+    console.log(e.reason); // "expected format: [operator]version..."
+  }
+}
+```
+
+**Validation functions never throw:**
+
+- `valid(version)` - Returns `false` for invalid input
+
+**Operation functions throw on invalid input:**
+
+- `parse()`, `clean()`, `compare()`, `satisfies()`, etc.
+
+## Performance
+
+### Algorithm Complexity
+
+- `parse()`, `compare()`: O(1)
+- `sort()`: O(n log n)
+- `maxSatisfying()`, `minSatisfying()`: O(n) - optimized to avoid full sort
+- Range parsing: O(k) where k = number of comparators
+
+### Optimization Tips
+
+**1. Reuse Range objects**
+
+```typescript
+// ❌ Slow: Parse range on every call
+for (const version of manyVersions) {
+  if (satisfies(version, ">=2.0 <3.0")) {
+    /* ... */
+  }
+}
+
+// ✅ Fast: Parse once, reuse unlimited times
+const range = new Range(">=2.0 <3.0");
+for (const version of manyVersions) {
+  if (satisfies(version, range)) {
+    /* ... */
+  }
+}
+```
+
+**2. Use appropriate algorithms**
+
+```typescript
+// ❌ Unnecessary: Full sort just to find max
+const sorted = sort(versions);
+const max = sorted[sorted.length - 1];
+
+// ✅ Efficient: O(n) instead of O(n log n)
+const max = maxSatisfying(versions, ">=0.0.0");
+```
+
+## Security
+
+Built-in protections against common vulnerabilities:
+
+**ReDoS Protection:**
+
+- Maximum input length: 100 chars (versions), 1000 chars (ranges)
+- Throws `VersionParseError` or `RangeParseError` if exceeded
+
+**Integer Overflow Protection:**
+
+- Version components capped at 2³¹-1 (max safe int32)
+- Ensures cross-platform interoperability
+- Throws `VersionParseError` if exceeded
+
+**Input Sanitization:**
+
+- Comprehensive validation rejects malformed input early
+- Structured errors for debugging
+
+## Version Format
+
+- **Generic numeric versions:** `major[.minor][.patch]`
+- **Missing components default to 0:** `"2"` → `{ major: 2, minor: 0, patch: 0 }`
+- **Whitespace is trimmed:** `" 2.5.1 "` → `"2.5.1"`
+- **No prerelease/build metadata**
+- **No wildcards, hyphen ranges, or `^`/`~` operators**
+
+## Range Syntax
+
+**Operators:**
+
+- `=` or omitted - Exact match
+- `<` - Less than
+- `<=` - Less than or equal
+- `>` - Greater than
+- `>=` - Greater than or equal
+
+**Multiple comparators:**
+
+- Space-separated for AND logic: `">=2.3 <3.0"`
+- All comparators must be satisfied
+
+**Examples:**
+
+```typescript
+"2.5.1"; // Exact match
+">=2.0"; // Greater than or equal to 2.0
+">=2.0 <3.0"; // Between 2.0 (inclusive) and 3.0 (exclusive)
+">=2.3 <2.6 >2.4"; // Multiple AND conditions
+```
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide][github-contributing] for more details.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Code of Conduct
+
+To ensure a welcoming and positive environment, we have a [Code of Conduct][github-code-of-conduct] that all contributors and participants are expected to adhere to.
+
+## License
+
+Copyright 2025 Rethink Health, SUARL. All rights reserved.
+
+This program is licensed to you under the terms of the [MIT License](https://opensource.org/licenses/MIT). This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the [LICENSE][github-license] file for details.
+
+[github-code-of-conduct]: https://github.com/rethinkhealth/glion/blob/main/CODE_OF_CONDUCT.md
+[github-license]: https://github.com/rethinkhealth/glion/blob/main/LICENSE
+[github-contributing]: https://github.com/rethinkhealth/glion/blob/main/CONTRIBUTING.md

package/dist/collection.d.ts

@@ -0,0 +1,67 @@
+import type { Range } from "./range";
+/**
+ * Sorts an array of version strings in ascending order.
+ *
+ * @example
+ *   ```typescript
+ *   sort(["2.5", "2.3.1", "2.10.0"]);
+ *   // => ["2.3.1", "2.5", "2.10.0"]
+ *
+ *   sort(["2.10", "2.9", "2.8"]);
+ *   // => ["2.8", "2.9", "2.10"]
+ *   ```;
+ *
+ * @param versions - Array of version strings to sort
+ * @returns New sorted array (does not mutate input)
+ * @throws {VersionParseError} If any version string is invalid
+ */
+export declare function sort(versions: string[]): string[];
+/**
+ * Finds the highest version that satisfies a range.
+ *
+ * @example
+ *   ```typescript
+ *   maxSatisfying(["2.3.0", "2.5.1", "3.0.0"], ">=2.0 <3.0");
+ *   // => "2.5.1"
+ *
+ *   maxSatisfying(["2.3.0", "2.5.1"], ">=3.0");
+ *   // => null (no matches)
+ *
+ *   // Use Range object for better performance with many versions
+ *   const range = new Range(">=2.0 <3.0");
+ *   maxSatisfying(["2.3.0", "2.5.1", "3.0.0"], range);
+ *   // => "2.5.1"
+ *   ```;
+ *
+ * @param versions - Array of version strings to search
+ * @param range - Range expression string or pre-parsed Range object
+ * @returns Highest matching version, or null if none match
+ * @throws {VersionParseError} If any version string is invalid
+ * @throws {RangeParseError} If range expression is invalid
+ */
+export declare function maxSatisfying(versions: string[], range: string | Range): string | null;
+/**
+ * Finds the lowest version that satisfies a range.
+ *
+ * @example
+ *   ```typescript
+ *   minSatisfying(["2.3.0", "2.5.1", "3.0.0"], ">=2.0 <3.0");
+ *   // => "2.3.0"
+ *
+ *   minSatisfying(["2.3.0", "2.5.1"], ">=3.0");
+ *   // => null (no matches)
+ *
+ *   // Use Range object for better performance with many versions
+ *   const range = new Range(">=2.0 <3.0");
+ *   minSatisfying(["2.3.0", "2.5.1", "3.0.0"], range);
+ *   // => "2.3.0"
+ *   ```;
+ *
+ * @param versions - Array of version strings to search
+ * @param range - Range expression string or pre-parsed Range object
+ * @returns Lowest matching version, or null if none match
+ * @throws {VersionParseError} If any version string is invalid
+ * @throws {RangeParseError} If range expression is invalid
+ */
+export declare function minSatisfying(versions: string[], range: string | Range): string | null;
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,MAAM,GAAG,KAAK,GACpB,MAAM,GAAG,IAAI,CAaf;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,MAAM,GAAG,KAAK,GACpB,MAAM,GAAG,IAAI,CAaf"}

package/dist/compare.d.ts

@@ -0,0 +1,124 @@
+import type { ComparisonResult, Hl7Version } from "./types";
+/**
+ * Compares two versions and returns their relationship.
+ *
+ * @example
+ *   ```typescript
+ *   compare("2.5.1", "2.5.0"); // => 1
+ *   compare("2.3", "2.5"); // => -1
+ *   compare("2.5.1", "2.5.1"); // => 0
+ *
+ *   // Works with parsed versions too
+ *   const v1 = parse("2.5.1");
+ *   const v2 = parse("2.5.0");
+ *   compare(v1, v2); // => 1
+ *   ```;
+ *
+ * @param a - First version (string or parsed object)
+ * @param b - Second version (string or parsed object)
+ * @returns -1 if a < b, 0 if a = b, 1 if a > b
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function compare(a: string | Hl7Version, b: string | Hl7Version): ComparisonResult;
+/**
+ * Checks if two versions are equal.
+ *
+ * @example
+ *   ```typescript
+ *   eq("2.5.1", "2.5.1"); // => true
+ *   eq("2.5", "2.5.0"); // => true (normalized)
+ *   eq("2.5.1", "2.5.0"); // => false
+ *   ```;
+ *
+ * @param a - First version (string or parsed object)
+ * @param b - Second version (string or parsed object)
+ * @returns True if versions are equal, false otherwise
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function eq(a: string | Hl7Version, b: string | Hl7Version): boolean;
+/**
+ * Checks if first version is less than second version.
+ *
+ * @example
+ *   ```typescript
+ *   lt("2.3.0", "2.5.1"); // => true
+ *   lt("2.5.1", "2.5.1"); // => false
+ *   lt("2.5.1", "2.3.0"); // => false
+ *   ```;
+ *
+ * @param a - First version (string or parsed object)
+ * @param b - Second version (string or parsed object)
+ * @returns True if a < b, false otherwise
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function lt(a: string | Hl7Version, b: string | Hl7Version): boolean;
+/**
+ * Checks if first version is less than or equal to second version.
+ *
+ * @example
+ *   ```typescript
+ *   lte("2.3.0", "2.5.1"); // => true
+ *   lte("2.5.1", "2.5.1"); // => true
+ *   lte("2.5.1", "2.3.0"); // => false
+ *   ```;
+ *
+ * @param a - First version (string or parsed object)
+ * @param b - Second version (string or parsed object)
+ * @returns True if a <= b, false otherwise
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function lte(a: string | Hl7Version, b: string | Hl7Version): boolean;
+/**
+ * Checks if first version is greater than second version.
+ *
+ * @example
+ *   ```typescript
+ *   gt("2.5.1", "2.3.0"); // => true
+ *   gt("2.5.1", "2.5.1"); // => false
+ *   gt("2.3.0", "2.5.1"); // => false
+ *   ```;
+ *
+ * @param a - First version (string or parsed object)
+ * @param b - Second version (string or parsed object)
+ * @returns True if a > b, false otherwise
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function gt(a: string | Hl7Version, b: string | Hl7Version): boolean;
+/**
+ * Checks if first version is greater than or equal to second version.
+ *
+ * @example
+ *   ```typescript
+ *   gte("2.5.1", "2.3.0"); // => true
+ *   gte("2.5.1", "2.5.1"); // => true
+ *   gte("2.3.0", "2.5.1"); // => false
+ *   ```;
+ *
+ * @param a - First version (string or parsed object)
+ * @param b - Second version (string or parsed object)
+ * @returns True if a >= b, false otherwise
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function gte(a: string | Hl7Version, b: string | Hl7Version): boolean;
+/**
+ * Determines the highest-level component that differs between two versions.
+ *
+ * @example
+ *   ```typescript
+ *   diff("2.5.1", "3.0.0"); // => "major"
+ *   diff("2.5.1", "2.6.0"); // => "minor"
+ *   diff("2.5.1", "2.5.2"); // => "patch"
+ *   diff("2.5.1", "2.5.1"); // => null (equal)
+ *
+ *   // Works with partial versions
+ *   diff("2", "2.0.0"); // => null (normalized to same)
+ *   diff("2.5", "2.6"); // => "minor"
+ *   ```;
+ *
+ * @param v1 - First version (string or parsed object)
+ * @param v2 - Second version (string or parsed object)
+ * @returns 'major', 'minor', 'patch', or null if versions are equal
+ * @throws {VersionParseError} If either input is an invalid version string
+ */
+export declare function diff(v1: string | Hl7Version, v2: string | Hl7Version): "major" | "minor" | "patch" | null;
+//# sourceMappingURL=compare.d.ts.map

package/dist/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,MAAM,GAAG,UAAU,EACtB,CAAC,EAAE,MAAM,GAAG,UAAU,GACrB,gBAAgB,CAWlB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAE1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAE1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAE3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAE1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAE3E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,IAAI,CAClB,EAAE,EAAE,MAAM,GAAG,UAAU,EACvB,EAAE,EAAE,MAAM,GAAG,UAAU,GACtB,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,IAAI,CAcpC"}

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Error thrown when a version string cannot be parsed.
+ */
+export declare class VersionParseError extends Error {
+    readonly name = "VersionParseError";
+    readonly input: string;
+    readonly reason: string;
+    constructor(input: string, reason: string);
+}
+/**
+ * Error thrown when a range token cannot be parsed.
+ */
+export declare class RangeParseError extends Error {
+    readonly name = "RangeParseError";
+    readonly token: string;
+    readonly reason: string;
+    constructor(token: string, reason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAkB,IAAI,uBAAuB;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAW1C;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAkB,IAAI,qBAAqB;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAW1C"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/** Biome-ignore-all lint/performance/noBarrelFile: fine */
+export { maxSatisfying, minSatisfying, sort } from "./collection";
+export { compare, diff, eq, gt, gte, lt, lte } from "./compare";
+export { RangeParseError, VersionParseError } from "./errors";
+export { clean, increment, parse, valid } from "./parse";
+export { Range, satisfies } from "./range";
+export type { Hl7Version } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAG3D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAEhE,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE9D,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGzD,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE3C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}