qte 0.0.1 → 0.1.0

package/README.md

@@ -1,10 +1,280 @@
-
 <div align="center">
-  <h1 align="center">qte</h1>
+  <h1 align="center">⏱️ <code>qte</code></h1>
 
   <p align="center">
-    <strong>Time conversion utilities</strong>
+    <strong>Parsing and formatting for human-readable time expressions.</strong>
+  </p>
+
+  <p align="center">
+    <a href="https://www.npmjs.com/package/qte"><img src="https://img.shields.io/npm/v/qte" alt="npm version"></a>
+    <a href="https://pkg-size.dev/qte"><img src="https://pkg-size.dev/badge/bundle/qte" alt="bundle size"></a>
+    <a href="https://github.com/adelrodriguez/qte/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/qte" alt="license"></a>
   </p>
 </div>
 
-Made with [🥐 `pastry`](https://github.com/adelrodriguez/pastry)
+## Features
+
+- Parse time strings into any unit (milliseconds, seconds, minutes, hours, days, weeks, months, years)
+- Compound expressions (`"1h 30m"`, `"1 day, 6 hours"`)
+- Format milliseconds back to human-readable strings with configurable precision
+- Tree-shakeable named exports
+- TypeScript `TimeExpression` type with compile-time checking and `isTimeExpression` / `isCompoundTimeExpression` guards
+- Zero dependencies
+
+## Install
+
+```bash
+npm install qte
+# or
+bun add qte
+# or
+pnpm add qte
+```
+
+## Quick Start
+
+```ts
+import { parse, format, ms, seconds, MS_PER_WEEK } from "qte"
+
+parse("2 days, 6 hours") // 194_400_000
+format(3_600_000) // "1h"
+format(5_432_100, { precision: 3 }) // "1h 30m 32s"
+format(5 * MS_PER_WEEK, { precision: 2 }) // "1mo 1w" (approximate)
+ms("1h") // 3_600_000
+seconds("30m") // 1800
+```
+
+## API
+
+### `parse`
+
+Parses a time expression and returns the value in milliseconds.
+
+```ts
+import { parse } from "qte"
+
+parse("1h") // 3_600_000
+parse("30s") // 30_000
+parse("1h 30m") // 5_400_000
+parse("1 day, 6 hours, 30 minutes") // 109_800_000
+```
+
+### `format`
+
+Converts milliseconds to a human-readable time expression.
+
+```ts
+import { format } from "qte"
+
+format(3_600_000) // "1h"
+format(500) // "500ms"
+format(0) // "0ms"
+format(-3_600_000) // "-1h"
+```
+
+#### Options
+
+| Option      | Type      | Default | Description                               |
+| ----------- | --------- | ------- | ----------------------------------------- |
+| `long`      | `boolean` | `false` | Use verbose format (`"1 hour"` vs `"1h"`) |
+| `precision` | `number`  | `1`     | Maximum number of unit segments to output |
+
+```ts
+format(3_600_000, { long: true }) // "1 hour"
+format(5_432_100, { precision: 3 }) // "1h 30m 32s"
+format(5_400_000, { long: true, precision: 2 }) // "1 hour 30 minutes"
+```
+
+#### Precision
+
+When `precision` is `1` (the default), the value is rounded to the single largest applicable unit. Higher values decompose the duration into multiple segments, with the last segment rounded to absorb the remainder.
+
+If the value has fewer meaningful segments than the requested precision, only the meaningful segments are returned:
+
+```ts
+format(3_600_000, { precision: 5 }) // "1h"
+format(500, { precision: 10 }) // "500ms"
+```
+
+Month/year units use fixed average durations, so low precision can produce noticeable approximation around week/month boundaries:
+
+```ts
+format(5 * MS_PER_WEEK, { precision: 2 }) // "1mo 1w" (approximate)
+```
+
+The output of `format` is always a valid input for `parse`:
+
+```ts
+const expr = format(5_400_000, { precision: 2 }) // "1h 30m"
+parse(expr) // 5_400_000
+
+const negativeExpr = format(-5_400_000, { precision: 2 }) // "-1h 30m"
+parse(negativeExpr) // -5_400_000
+```
+
+### Unit Functions
+
+Each function parses a single time expression and returns the value in the named unit. For compound expressions, use `parse` instead.
+
+```ts
+import { ms, seconds, minutes, hours, days, weeks, months, years } from "qte"
+
+ms("1s") // 1000
+seconds("1h") // 3600
+seconds("500ms") // 0.5
+minutes("2h") // 120
+hours("1d") // 24
+days("1w") // 7
+weeks("1y") // 52.1775
+```
+
+### `isTimeExpression`
+
+Type guard that checks if a string is a valid single time expression. Returns `false` for compound expressions like `"1h 30m"`. Never throws.
+
+```ts
+import { isTimeExpression } from "qte"
+
+isTimeExpression("1h") // true
+isTimeExpression("500ms") // true
+isTimeExpression("1h 30m") // false (use isCompoundTimeExpression)
+isTimeExpression("hello") // false
+
+const input: string = getUserInput()
+if (isTimeExpression(input)) {
+  ms(input) // TypeScript knows `input` is TimeExpression
+}
+```
+
+### `isCompoundTimeExpression`
+
+Checks if a string is a valid time expression (simple or compound). Never throws.
+
+```ts
+import { isCompoundTimeExpression } from "qte"
+
+isCompoundTimeExpression("1h") // true
+isCompoundTimeExpression("1h 30m") // true
+isCompoundTimeExpression("hello") // false
+
+const input: string = getUserInput()
+if (isCompoundTimeExpression(input)) {
+  parse(input) // input is a valid time expression
+}
+```
+
+### Constants
+
+Millisecond-based conversion factors for custom arithmetic (e.g. computing a cache TTL or rate limit window):
+
+```ts
+import {
+  MS_PER_SECOND, // 1_000
+  MS_PER_MINUTE, // 60_000
+  MS_PER_HOUR, // 3_600_000
+  MS_PER_DAY, // 86_400_000
+  MS_PER_WEEK, // 604_800_000
+  MS_PER_MONTH, // 2_629_800_000
+  MS_PER_YEAR, // 31_557_600_000
+} from "qte"
+```
+
+## Compound Expressions
+
+The parser supports multi-part expressions. Parts are summed together.
+
+```ts
+// Space-separated
+parse("1h 30m") // 5_400_000
+
+// Comma-separated (single commas only)
+parse("1h, 30m") // 5_400_000
+
+// Concatenated (no separator)
+parse("1h30m") // 5_400_000
+
+// Long form
+parse("1 hour 30 minutes") // 5_400_000
+parse("1 year 2 weeks 5 days") // 32_594_400_000
+
+// Duplicate units are additive
+parse("1h 2h") // 10_800_000
+
+// Order doesn't matter
+parse("30m 1h") // 5_400_000
+```
+
+Malformed delimiter punctuation is rejected (`",1h"`, `"1h,"`, `"1h,,30m"`, and `"1h, ,30m"` are invalid).
+Numeric token pattern is `[+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?`, so exponent notation is supported.
+
+### Supported Units
+
+All units are case-insensitive. Spaces between number and unit are optional.
+
+| Unit         | Short | Aliases                                        |
+| ------------ | ----- | ---------------------------------------------- |
+| Milliseconds | `ms`  | `milliseconds`, `millisecond`, `msecs`, `msec` |
+| Seconds      | `s`   | `seconds`, `second`, `secs`, `sec`             |
+| Minutes      | `m`   | `minutes`, `minute`, `mins`, `min`             |
+| Hours        | `h`   | `hours`, `hour`, `hrs`, `hr`                   |
+| Days         | `d`   | `days`, `day`                                  |
+| Weeks        | `w`   | `weeks`, `week`                                |
+| Months       | `mo`  | `months`, `month`                              |
+| Years        | `y`   | `years`, `year`, `yrs`, `yr`                   |
+
+### Signed Expressions
+
+A leading sign applies to the entire compound expression when later parts are unsigned. Explicit signs on later segments override this and are evaluated per segment.
+
+```ts
+parse("-1h 30m") // -5_400_000
+parse("+1h 30m") // 5_400_000
+parse("-1h +30m") // -1_800_000
+parse("-1h -30m") // -5_400_000
+parse("-1h 30m -10m") // -2_400_000
+parse("-1h 30m +10m") // -1_200_000
+parse("1h-30m") // 1_800_000
+parse("1h+30m") // 5_400_000
+```
+
+## Types
+
+```ts
+import type { TimeExpression, FormatOptions, Unit } from "qte"
+```
+
+- **`TimeExpression`** — A template literal type for single time expressions (`"1h"`, `"30s"`, `"500ms"`). Rejects invalid string literals at compile time. Used by unit functions (`ms`, `seconds`, etc.).
+- **`FormatOptions`** — Options for `format()` (`long`, `precision`).
+- **`Unit`** — Union of all recognized unit strings (e.g. `"hours"`, `"h"`, `"hr"`).
+
+Use the type guards to validate strings at runtime:
+
+```ts
+const input: string = getUserInput()
+if (isTimeExpression(input)) {
+  ms(input) // `input` is narrowed to TimeExpression
+}
+if (isCompoundTimeExpression(input)) {
+  parse(input) // input is a valid expression (simple or compound)
+}
+```
+
+## Error Handling
+
+**`parse` and unit functions:**
+
+- Throw a `TypeError` if the input is not a string, is empty, or exceeds 200 characters.
+- Return `NaN` if the string cannot be parsed.
+
+**`format`:**
+
+- Throws a `TypeError` if the input is not a finite number (`Infinity`, `-Infinity`, `NaN`).
+- Throws a `RangeError` if `precision` is not a finite positive integer (e.g. `0`, negative numbers, `NaN`, `Infinity`, or decimals).
+
+**`isTimeExpression` and `isCompoundTimeExpression`:**
+
+- Never throw. Return `false` for any invalid input.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,2 +1,244 @@
-declare function main(): string;
-export { main };
+/** Milliseconds in one second (`1_000`). */
+declare const MS_PER_SECOND = 1e3;
+/** Milliseconds in one minute (`60_000`). */
+declare const MS_PER_MINUTE: number;
+/** Milliseconds in one hour (`3_600_000`). */
+declare const MS_PER_HOUR: number;
+/** Milliseconds in one day (`86_400_000`). */
+declare const MS_PER_DAY: number;
+/** Milliseconds in one week (`604_800_000`). */
+declare const MS_PER_WEEK: number;
+/** Milliseconds in one year (`31_557_600_000`), based on 365.25 days. */
+declare const MS_PER_YEAR: number;
+/** Milliseconds in one month (`2_629_800_000`), derived as one twelfth of a year. */
+declare const MS_PER_MONTH: number;
+/** Year unit aliases. */
+type Years = "years" | "year" | "yrs" | "yr" | "y";
+/** Month unit aliases. */
+type Months = "months" | "month" | "mo";
+/** Week unit aliases. */
+type Weeks = "weeks" | "week" | "w";
+/** Day unit aliases. */
+type Days = "days" | "day" | "d";
+/** Hour unit aliases. */
+type Hours = "hours" | "hour" | "hrs" | "hr" | "h";
+/** Minute unit aliases. */
+type Minutes = "minutes" | "minute" | "mins" | "min" | "m";
+/** Second unit aliases. */
+type Seconds = "seconds" | "second" | "secs" | "sec" | "s";
+/** Millisecond unit aliases. */
+type Milliseconds = "milliseconds" | "millisecond" | "msecs" | "msec" | "ms";
+/** Union of all recognized time unit strings. */
+type Unit = Years | Months | Weeks | Days | Hours | Minutes | Seconds | Milliseconds;
+/** Any casing variant of a time unit (lowercase, Capitalized, UPPERCASE). */
+type UnitAnyCase = Unit | Capitalize<Unit> | Uppercase<Unit>;
+/**
+* A single time expression: a bare number, or a number followed by a unit
+* (with or without a space).
+*/
+type TimeExpression = `${number}` | `${number}${UnitAnyCase}` | `${number} ${UnitAnyCase}`;
+/** Options for {@link format}. */
+interface FormatOptions {
+	/** Use verbose formatting (`"1 hour"` instead of `"1h"`). Defaults to `false`. */
+	long?: boolean;
+	/** Maximum number of unit segments to include. Defaults to `1`. */
+	precision?: number;
+}
+/**
+* Format a millisecond value into a human-readable time expression.
+*
+* The returned string can be passed back into {@link parse} for
+* round-trip conversion.
+*
+* @param milliseconds - The value in milliseconds to format
+* @param options - Formatting options
+* @returns A formatted time expression string
+* @throws {TypeError} If the input is not a finite number
+* @throws {RangeError} If `options.precision` is not a finite positive integer
+*
+* @example
+* ```ts
+* format(3_600_000)                        // "1h"
+* format(3_600_000, { long: true })        // "1 hour"
+* format(500)                              // "500ms"
+* format(5_432_100, { precision: 3 })      // "1h 30m 32s"
+* ```
+*/
+declare function format(milliseconds: number, options?: FormatOptions): string;
+/**
+* Check whether a string is a valid single time expression without throwing.
+*
+* Acts as a TypeScript type guard — when it returns `true`, the input is
+* narrowed to {@link TimeExpression}. Unlike {@link isCompoundTimeExpression},
+* this rejects compound expressions such as `"1h 30m"`.
+*
+* @param value - The string to validate
+* @returns `true` if the string is a valid single time expression
+*
+* @example
+* ```ts
+* isTimeExpression("1h")      // true
+* isTimeExpression("500ms")   // true
+* isTimeExpression("1h 30m")  // false (compound)
+* isTimeExpression("hello")   // false
+*
+* const input: string = getUserInput()
+* if (isTimeExpression(input)) {
+*   ms(input) // TypeScript knows `input` is TimeExpression
+* }
+* ```
+*/
+declare function isTimeExpression(value: string): value is TimeExpression;
+/**
+* Check whether a string is a valid time expression (simple or compound)
+* without throwing.
+*
+* This accepts both simple expressions (`"1h"`) and compound expressions
+* (`"1h 30m"`).
+*
+* @param value - The string to validate
+* @returns `true` if the string is a valid time expression
+*
+* @example
+* ```ts
+* isCompoundTimeExpression("1h")      // true
+* isCompoundTimeExpression("1h 30m")  // true
+* isCompoundTimeExpression("hello")   // false
+* isCompoundTimeExpression("")        // false
+*
+* const input: string = getUserInput()
+* if (isCompoundTimeExpression(input)) {
+*   parse(input) // input is a valid time expression
+* }
+* ```
+*/
+declare function isCompoundTimeExpression(value: string): boolean;
+/**
+* Parse a time expression string into milliseconds.
+*
+* Accepts both simple (`"1h"`) and compound (`"1h 30m"`) expressions.
+* Parts are summed together. Duplicate units are additive.
+* Supports space separators, a single comma separator, or no separator.
+* Numeric tokens support optional exponent notation (e.g. `"1e3ms"`).
+* A leading sign on a compound expression applies to the whole expression
+* unless later parts declare their own explicit signs.
+*
+* @param value - A time expression string to parse
+* @returns The total value in milliseconds, or `NaN` if the string cannot be parsed
+* @throws {TypeError} If the input is not a string, is empty, or exceeds 200 characters
+*
+* @example
+* ```ts
+* parse("1h")           // 3_600_000
+* parse("30s")          // 30_000
+* parse("1h 30m")       // 5_400_000
+* parse("1 day, 6 hours, 30 minutes") // 109_800_000
+* ```
+*/
+declare function parse(value: string): number;
+/**
+* Parse a time expression and return the value in milliseconds.
+*
+* @param value - A time expression string
+* @returns The value in milliseconds
+*
+* @example
+* ```ts
+* ms("1s")  // 1000
+* ms("5m")  // 300_000
+* ms("1h")  // 3_600_000
+* ```
+*/
+declare function ms(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in seconds.
+*
+* @param value - A time expression string
+* @returns The value in seconds
+*
+* @example
+* ```ts
+* seconds("1h")    // 3600
+* seconds("500ms") // 0.5
+* ```
+*/
+declare function seconds(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in minutes.
+*
+* @param value - A time expression string
+* @returns The value in minutes
+*
+* @example
+* ```ts
+* minutes("2h")  // 120
+* minutes("30s") // 0.5
+* ```
+*/
+declare function minutes(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in hours.
+*
+* @param value - A time expression string
+* @returns The value in hours
+*
+* @example
+* ```ts
+* hours("1d")   // 24
+* hours("30m")  // 0.5
+* ```
+*/
+declare function hours(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in days.
+*
+* @param value - A time expression string
+* @returns The value in days
+*
+* @example
+* ```ts
+* days("1w")  // 7
+* days("12h") // 0.5
+* ```
+*/
+declare function days(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in weeks.
+*
+* @param value - A time expression string
+* @returns The value in weeks
+*
+* @example
+* ```ts
+* weeks("14d") // 2
+* weeks("1y")  // 52.1775
+* ```
+*/
+declare function weeks(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in months.
+*
+* @param value - A time expression string
+* @returns The value in months
+*
+* @example
+* ```ts
+* months("1y")  // 12
+* months("60d") // ~1.97
+* ```
+*/
+declare function months(value: TimeExpression): number;
+/**
+* Parse a time expression and return the value in years.
+*
+* @param value - A time expression string
+* @returns The value in years
+*
+* @example
+* ```ts
+* years("365.25d") // 1
+* years("6mo")     // 0.5
+* ```
+*/
+declare function years(value: TimeExpression): number;
+export { years, weeks, seconds, parse, ms, months, minutes, isTimeExpression, isCompoundTimeExpression, hours, format, days, Years, Weeks, Unit, TimeExpression, Seconds, Months, Minutes, Milliseconds, MS_PER_YEAR, MS_PER_WEEK, MS_PER_SECOND, MS_PER_MONTH, MS_PER_MINUTE, MS_PER_HOUR, MS_PER_DAY, Hours, FormatOptions, Days };

package/dist/index.js

@@ -1,10 +1 @@
-// src/index.ts
-function main() {
-  return "Let's bake some pastry! \uD83E\uDD50";
-}
-export {
-  main
-};
-
-//# debugId=B3F3B1D74DE4157564756E2164756E21
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsic3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWwogICAgImV4cG9ydCBmdW5jdGlvbiBtYWluKCkge1xuICByZXR1cm4gXCJMZXQncyBiYWtlIHNvbWUgcGFzdHJ5ISDwn6WQXCJcbn1cbiIKICBdLAogICJtYXBwaW5ncyI6ICI7QUFBTyxTQUFTLElBQUksR0FBRztBQUFBLEVBQ3JCLE9BQU87QUFBQTsiLAogICJkZWJ1Z0lkIjogIkIzRjNCMUQ3NERFNDE1NzU2NDc1NkUyMTY0NzU2RTIxIiwKICAibmFtZXMiOiBbXQp9
+var B=1000,X=60000,F=3600000,G=86400000,H=604800000,f=31557600000,L=2629800000;var K=[{aliases:["years","year","yrs","yr","y"],long:"year",longPlural:"years",ms:f,short:"y"},{aliases:["months","month","mo"],long:"month",longPlural:"months",ms:L,short:"mo"},{aliases:["weeks","week","w"],long:"week",longPlural:"weeks",ms:H,short:"w"},{aliases:["days","day","d"],long:"day",longPlural:"days",ms:G,short:"d"},{aliases:["hours","hour","hrs","hr","h"],long:"hour",longPlural:"hours",ms:F,short:"h"},{aliases:["minutes","minute","mins","min","m"],long:"minute",longPlural:"minutes",ms:X,short:"m"},{aliases:["seconds","second","secs","sec","s"],long:"second",longPlural:"seconds",ms:B,short:"s"},{aliases:["milliseconds","millisecond","msecs","msec","ms"],long:"millisecond",longPlural:"milliseconds",ms:1,short:"ms"}];function S(y){return y.replaceAll(/[.*+?^${}()|[\]\\]/g,"\\$&")}var C=[...new Set(K.flatMap((y)=>y.aliases))],T=new Map(K.flatMap((y)=>y.aliases.map((k)=>[k,y.ms]))),V=C.toSorted((y,k)=>k.length-y.length).map((y)=>S(y)).join("|");function I(y){return T.get(y)??Number.NaN}function P(y){let k=K.at(y);if(!k)throw Error(`Invalid unit index: ${y}`);return k}function Z(y,k,_){if(_){let Y=Math.abs(y)===1?k.long:k.longPlural;return`${y} ${Y}`}return`${y}${k.short}`}function c(y,k){if(typeof y!=="number"||!Number.isFinite(y))throw TypeError(`Value provided to format() must be a finite number. Received: ${String(y)}`);let _=k?.long??!1,Y=k?.precision??1;if(!Number.isFinite(Y)||!Number.isInteger(Y)||Y<1)throw RangeError(`Option "precision" must be a finite positive integer. Received: ${String(Y)}`);if(y===0)return Z(0,P(K.length-1),_);let $=y<0,D=Math.abs(y);if(Y===1)return d(y,D,_);return m(D,$,_,Y)}function d(y,k,_){let Y=y<0?-1:1;for(let q of K)if(k>=q.ms){let M=Math.round(k/q.ms),j=M===0?0:Y*M;return Z(j,q,_)}let $=P(K.length-1),D=Math.round(k/$.ms),z=D===0?0:Y*D;return Z(z,$,_)}function m(y,k,_,Y){let $=y,D=[];for(let M=0;M<K.length&&D.length<Y;M+=1){let j=P(M);if(D.length===Y-1){let J=Math.round($/j.ms);if(J>0){D.push({unitIdx:M,value:J});break}continue}let w=Math.floor($/j.ms);if(w>0)D.push({unitIdx:M,value:w}),$-=w*j.ms}if(D.length===0){let M=P(K.length-1),j=Math.round(y/M.ms);D.push({unitIdx:K.length-1,value:j})}for(let M=D.length-1;M>=0;M-=1){let j=D[M],w=P(j.unitIdx),J=j.unitIdx-1;if(J<0)continue;let Q=P(J).ms/w.ms;if(j.value>=Q){let R=Math.floor(j.value/Q);j.value-=R*Q;let W=M>0?D[M-1]:void 0;if(W&&W.unitIdx===J)W.value+=R;else D.splice(M,0,{unitIdx:J,value:R}),M+=1}}while(D.length>1){let M=D.at(-1);if(!M||M.value!==0)break;D.pop()}if(D.length===0)return Z(0,P(K.length-1),_);if(D.every((M)=>M.value===0))return Z(0,P(K.length-1),_);let q=D.map((M)=>Z(M.value,P(M.unitIdx),_)).join(" ");return k?`-${q}`:q}var h=200,x=new RegExp(`([+-]?\\d*\\.?\\d+(?:e[+-]?\\d+)?)\\s*(${V})?`,"gi"),U=/^\s*$/,o=/^\s*,\s*$/;function p(y,k){if(U.test(y))return!0;if(k)return!1;return o.test(y)}function O(y){if(typeof y!=="string"||y.length===0||y.length>h)throw TypeError(`Value provided to parse() must be a string with length between 1 and ${h}. Received: ${String(y)}`);x.lastIndex=0;let k=0,_=0,Y=0,$=0,D=!1,z=!1,q=!1,M;while((M=x.exec(y))!==null){let A=y.slice(Y,M.index);if(!p(A,$===0))return Number.NaN;let Q=M[1]??"",R=M[2];if(!R)D=!0;let W=Q.startsWith("-")||Q.startsWith("+");if($===0)z=W;else if(W)q=!0;let E=Number.parseFloat(Q),b=R?I(R.toLowerCase()):1;if(!Number.isFinite(E)||Number.isNaN(b))return Number.NaN;let N=E*b;if(!Number.isFinite(N))return Number.NaN;if(k+=N,!Number.isFinite(k))return Number.NaN;if(_+=Math.abs(N),!Number.isFinite(_))return Number.NaN;Y=M.index+M[0].length,$+=1}if($===0)return Number.NaN;if($>1&&D)return Number.NaN;let j=y.slice(Y);if(!U.test(j))return Number.NaN;let w=y.trimStart(),J=w.startsWith("-")||w.startsWith("+");if($>1&&J&&z&&!q)return w.startsWith("-")?-_:_;return k}function v(y){return O(y)}function g(y){return O(y)/B}function r(y){return O(y)/X}function l(y){return O(y)/F}function s(y){return O(y)/G}function u(y){return O(y)/H}function n(y){return O(y)/L}function a(y){return O(y)/f}var t=new RegExp(`^[+-]?\\d*\\.?\\d+(?:e[+-]?\\d+)?(?: ?(?:${V}))?$`,"i");function i(y){try{if(!t.test(y))return!1;return!Number.isNaN(O(y))}catch{return!1}}function e(y){try{return!Number.isNaN(O(y))}catch{return!1}}export{a as years,u as weeks,g as seconds,O as parse,v as ms,n as months,r as minutes,i as isTimeExpression,e as isCompoundTimeExpression,l as hours,c as format,s as days,f as MS_PER_YEAR,H as MS_PER_WEEK,B as MS_PER_SECOND,L as MS_PER_MONTH,X as MS_PER_MINUTE,F as MS_PER_HOUR,G as MS_PER_DAY};

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "qte",
-  "version": "0.0.1",
-  "description": "Time conversion utilities",
+  "version": "0.1.0",
+  "description": "Parse human-readable time expressions into any unit, and format durations into human-readable strings",
   "keywords": [
-    "bun",
-    "library",
-    "template"
+    "convert",
+    "duration",
+    "format",
+    "human-readable",
+    "milliseconds",
+    "ms",
+    "parse",
+    "time"
   ],
   "homepage": "https://github.com/adelrodriguez/qte#readme",
   "bugs": {
@@ -15,18 +20,27 @@
   "author": "Adel Rodríguez",
   "repository": {
     "type": "git",
-    "url": "https://github.com/adelrodriguez/qte.git"
+    "url": "git+https://github.com/adelrodriguez/qte.git"
   },
   "files": [
     "dist"
   ],
   "type": "module",
-  "module": "src/index.ts",
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
   "scripts": {
     "build": "bunup",
+    "build:debug": "bunup --sourcemap inline --no-minify",
     "bump:deps": "bun update --interactive",
     "check": "adamantite check",
-    "dev": "bunup --watch",
+    "dev": "bunup --watch --sourcemap inline --no-minify",
     "fix": "adamantite fix",
     "release": "changeset publish",
     "init": "bun run --bun scripts/init.ts",