@scaleway/units 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+$ tsdown
+ℹ tsdown v0.22.9 powered by rolldown v1.2.0
+ℹ config file: /home/runner/work/scaleway-lib/scaleway-lib/packages/units/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ targets: chrome111, edge111, firefox114, safari16.4, ios16.4
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+
+ WARN  TypeScript 7.0 does not yet have a stable API and is experimental. Some options will be unavailable.
+
+ℹ Emit types with typescript@7.0.2
+ℹ dist/index.js              0.50 kB │ gzip: 0.17 kB
+ℹ dist/convertDuration.js    2.13 kB │ gzip: 0.78 kB
+ℹ dist/convertUnit.js        2.11 kB │ gzip: 0.95 kB
+ℹ dist/constants.js          1.04 kB │ gzip: 0.29 kB
+ℹ dist/index.d.ts            0.49 kB │ gzip: 0.17 kB
+ℹ dist/convertUnit.d.ts      2.43 kB │ gzip: 0.95 kB
+ℹ dist/convertDuration.d.ts  1.46 kB │ gzip: 0.64 kB
+ℹ dist/constants.d.ts        0.59 kB │ gzip: 0.19 kB
+ℹ 8 files, total: 10.75 kB
+✔ Build complete in 577ms
+✔ [attw] No problems found (776ms)
+✔ [publint] No issues found (809ms)

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @scaleway/units
+
+## 1.0.0
+
+### Major Changes
+
+- [#3511](https://github.com/scaleway/scaleway-lib/pull/3511) [`6df42a7`](https://github.com/scaleway/scaleway-lib/commit/6df42a7d27d3b83320e067d556048c50b1221385) Thanks [@chambo-e](https://github.com/chambo-e)! - introduce @scaleway/units

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Scaleway
+
+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,164 @@
+# `@scaleway/units`
+
+A JS library to handle units and unit conversion
+
+- [Install](#install)
+- [`convertUnits`](#convertunits)
+  - [Usage](#usage)
+  - [Why two bases?](#why-two-bases)
+  - [Supported units](#supported-units)
+- [`convertDuration`](#convertduration)
+  - [Usage](#usage-1)
+  - [How it works](#how-it-works)
+  - [Supported units](#supported-units-1)
+  - [⚠️ Months and years are approximations](#-months-and-years-are-approximations)
+- [Constants](#constants)
+- [API](#api)
+  - [`convertUnit(amount, options)`](#convertunitamount-options)
+  - [`convertDuration(amount, options)`](#convertdurationamount-options)
+
+## Install
+
+```bash
+$ pnpm add @scaleway/units
+```
+
+## `convertUnits`
+
+A tiny utility for converting numeric values between unit prefixes (bytes ↔ kilobytes, bits ↔ megabits, grams ↔ kilograms, etc.), supporting both **SI\*- (decimal, base 10) and **IEC\*- (binary, base 2) prefixes.
+
+The prefixes themselves are unit-agnostic — `convertUnit` doesn't know or care whether `amount` represents bytes, grams, or anything else. The `base` option (10 or 2) is what determines the actual multiplier, so IEC (binary) prefixes only make sense for quantities that are naturally measured in powers of 2, like data.
+
+See [Binary prefix (Wikipedia)](https://en.wikipedia.org/wiki/Binary_prefix) for background on why these two systems exist and how they differ.
+
+### Usage
+
+```typescript
+import { convertUnit } from './convertUnit'
+
+// 1500 bytes -> kilobytes (decimal / SI)
+convertUnit(1500, { from: 'unit', to: 'kilo' })
+// => 1.5
+
+// 2 mebibytes -> bytes (binary / IEC)
+convertUnit(2, { from: 'mega', to: 'unit', base: 2 })
+// => 2097152
+
+// 500 gigabytes -> terabytes (decimal / SI)
+convertUnit(500, { from: 'giga', to: 'tera' })
+// => 0.5
+
+// 2.5 kilograms -> grams (decimal / SI)
+// convertUnit isn't data-specific — it works for any SI quantity
+convertUnit(2.5, { from: 'kilo', to: 'unit' })
+// => 2500
+```
+
+### Why two bases?
+
+| System | Base | Example                      |
+| ------ | ---- | ---------------------------- |
+| SI     | 10   | 1 kilobyte (kB) = 1000 bytes |
+| IEC    | 2    | 1 kibibyte = 1024 bytes      |
+
+Storage vendors typically advertise capacity in SI (decimal) units, while operating systems often report size in IEC (binary) units — this is why a "500 GB" drive shows up as roughly 465 GB in your file explorer. `convertUnit` lets you convert correctly under either convention by passing `base: 10` or `base: 2`.
+
+### Supported units
+
+```
+unit → kilo → mega → giga → tera → peta → exa → zetta → yotta
+```
+
+`from` and `to` can be any two of these units, in either direction — the function computes the exponent difference between them for the selected base, so you're not limited to converting to/from `'unit'`.
+
+## `convertDuration`
+
+A tiny utility for converting numeric durations between time units — milliseconds, seconds, minutes, hours, days, weeks, months, and years.
+
+### Usage
+
+```typescript
+import { convertDuration } from './convertDuration'
+
+// 90 seconds -> minutes
+convertDuration(90, { from: 'seconds', to: 'minutes' })
+// => 1.5
+
+// 3 hours -> milliseconds
+convertDuration(3, { from: 'hours', to: 'milliseconds' })
+// => 10800000
+
+// 2 weeks -> days
+convertDuration(2, { from: 'weeks', to: 'days' })
+// => 14
+
+// 18 months -> years
+convertDuration(18, { from: 'months', to: 'years' })
+// => 1.5
+```
+
+### How it works
+
+All conversions go through milliseconds as an intermediate step: `amount` is converted from the `from` unit to milliseconds, then from milliseconds to the `to` unit.
+
+### Supported units
+
+```
+milliseconds | seconds | minutes | hours | days | weeks | months | years
+```
+
+### ⚠️ Months and years are approximations
+
+This utility uses a \*_fixed 365-day year_- with no leap-year adjustment, and derives `months` from it:
+
+- 1 year = 365 days
+- 1 month = 365 / 12 ≈ 30.4167 days (\*_not_- a calendar month — every month is treated as the same length)
+
+This means:
+
+- Conversions involving `months` or `years` will drift from real calendar dates (e.g. they won't account for February being shorter, or leap years adding a day).
+- `convertDuration` is best suited for approximate/relative durations (e.g. "roughly how many hours is 3 months"), not for calendar-accurate date arithmetic. For exact calendar math, use a date library (e.g. `date-fns`, `Luxon`, `Day.js`) instead.
+
+## Constants
+
+This package also exports some predefined constants:
+
+```ts
+SECONDS_IN_MINUTE
+SECONDS_IN_HOUR
+SECONDS_IN_DAY
+SECONDS_IN_MONTH
+DAYS_IN_WEEK
+DAYS_IN_MONTH
+DAYS_IN_YEAR
+HOURS_IN_DAY
+HOURS_IN_MONTH
+MONTHS_IN_YEAR
+```
+
+## API
+
+### `convertUnit(amount, options)`
+
+Converts `amount` from one unit prefix to another.
+
+| Parameter      | Type                          | Description                                                |
+| -------------- | ----------------------------- | ---------------------------------------------------------- |
+| `amount`       | `number`                      | The value to convert.                                      |
+| `options.from` | `Unit` \*(default: `'unit'`)- | The prefix `amount` is currently expressed in.             |
+| `options.to`   | `Unit` \*(default: `'unit'`)- | The prefix to convert `amount` into.                       |
+| `options.base` | `2 \| 10` \*(default: `10`)-  | `10` for SI/decimal prefixes, `2` for IEC/binary prefixes. |
+
+Returns a `number`: `amount` expressed in the `to` unit.
+
+### `convertDuration(amount, options)`
+
+Converts `amount` from one time unit to another.
+
+| Parameter      | Type                             | Description                                  |
+| -------------- | -------------------------------- | -------------------------------------------- |
+| `amount`       | `number`                         | The duration to convert.                     |
+| `options.from` | `Unit` \*(default: `'seconds'`)- | The unit `amount` is currently expressed in. |
+| `options.to`   | `Unit` \*(default: `'seconds'`)- | The unit to convert `amount` into.           |
+
+Returns a `number`: `amount` expressed in the `to` unit.

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+//#region src/constants.d.ts
+declare const SECONDS_IN_MINUTE: number;
+declare const SECONDS_IN_HOUR: number;
+declare const SECONDS_IN_DAY: number;
+declare const SECONDS_IN_MONTH: number;
+declare const DAYS_IN_WEEK: number;
+declare const DAYS_IN_MONTH: number;
+declare const DAYS_IN_YEAR: number;
+declare const HOURS_IN_DAY: number;
+declare const HOURS_IN_MONTH: number;
+declare const MONTHS_IN_YEAR: number;
+//#endregion
+export { DAYS_IN_MONTH, DAYS_IN_WEEK, DAYS_IN_YEAR, HOURS_IN_DAY, HOURS_IN_MONTH, MONTHS_IN_YEAR, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH };

package/dist/constants.js

@@ -0,0 +1,44 @@
+import { convertDuration } from "./convertDuration.js";
+//#region src/constants.ts
+const SECONDS_IN_MINUTE = convertDuration(1, {
+	from: "minutes",
+	to: "seconds"
+});
+const SECONDS_IN_HOUR = convertDuration(1, {
+	from: "hours",
+	to: "seconds"
+});
+const SECONDS_IN_DAY = convertDuration(1, {
+	from: "days",
+	to: "seconds"
+});
+const SECONDS_IN_MONTH = convertDuration(1, {
+	from: "months",
+	to: "seconds"
+});
+const DAYS_IN_WEEK = convertDuration(1, {
+	from: "weeks",
+	to: "days"
+});
+const DAYS_IN_MONTH = convertDuration(1, {
+	from: "months",
+	to: "days"
+});
+const DAYS_IN_YEAR = convertDuration(1, {
+	from: "years",
+	to: "days"
+});
+const HOURS_IN_DAY = convertDuration(1, {
+	from: "days",
+	to: "hours"
+});
+const HOURS_IN_MONTH = convertDuration(1, {
+	from: "months",
+	to: "hours"
+});
+const MONTHS_IN_YEAR = convertDuration(1, {
+	from: "years",
+	to: "months"
+});
+//#endregion
+export { DAYS_IN_MONTH, DAYS_IN_WEEK, DAYS_IN_YEAR, HOURS_IN_DAY, HOURS_IN_MONTH, MONTHS_IN_YEAR, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH };

package/dist/convertDuration.d.ts

@@ -0,0 +1,40 @@
+//#region src/convertDuration.d.ts
+type Unit = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+type ConvertUnitArgs = {
+  from?: Unit;
+  to?: Unit;
+};
+/**
+ * Converts a numeric duration from one time unit to another.
+ *
+ * `amount` is first converted to milliseconds using `from`, then converted
+ * to the target unit using `to`. `months` and `years` are approximations
+ * based on a 365-day year (no leap-year adjustment), so a "month" is
+ * `365 / 12 ≈ 30.42` days — not a calendar month.
+ *
+ * @param amount - The numeric duration to convert.
+ * @param options - Conversion options.
+ * @param options.from - The unit `amount` is currently expressed in. Defaults to `'seconds'`.
+ * @param options.to - The unit to convert `amount` into. Defaults to `'seconds'`.
+ *
+ * @returns `amount` expressed in the `to` unit.
+ *
+ * @example
+ * // 90 seconds -> minutes
+ * convertDuration(90, { from: 'seconds', to: 'minutes' }) // 1.5
+ *
+ * @example
+ * // 3 hours -> milliseconds
+ * convertDuration(3, { from: 'hours', to: 'milliseconds' }) // 10800000
+ *
+ * @example
+ * // 2 weeks -> days
+ * convertDuration(2, { from: 'weeks', to: 'days' }) // 14
+ *
+ * @example
+ * // 18 months -> years (approximate, non-calendar months)
+ * convertDuration(18, { from: 'months', to: 'years' }) // 1.5
+ */
+declare const convertDuration: (amount: number, { from, to }: ConvertUnitArgs) => number;
+//#endregion
+export { convertDuration };

package/dist/convertDuration.js

@@ -0,0 +1,53 @@
+//#region src/convertDuration.ts
+const MILLISECONDS_IN_SECOND = 1e3;
+const SECONDS_IN_MINUTE = 60;
+const MINUTES_IN_HOUR = 60;
+const HOURS_IN_DAY = 24;
+const MONTHS_IN_YEAR = 12;
+const DAYS_IN_YEAR = 365;
+const millisecondsInUnit = {
+	milliseconds: 1,
+	seconds: MILLISECONDS_IN_SECOND,
+	minutes: MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE,
+	hours: MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE * MINUTES_IN_HOUR,
+	days: MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE * MINUTES_IN_HOUR * HOURS_IN_DAY,
+	weeks: MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE * MINUTES_IN_HOUR * HOURS_IN_DAY * 7,
+	months: MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE * MINUTES_IN_HOUR * HOURS_IN_DAY * (DAYS_IN_YEAR / MONTHS_IN_YEAR * HOURS_IN_DAY / HOURS_IN_DAY),
+	years: MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE * MINUTES_IN_HOUR * HOURS_IN_DAY * DAYS_IN_YEAR
+};
+/**
+* Converts a numeric duration from one time unit to another.
+*
+* `amount` is first converted to milliseconds using `from`, then converted
+* to the target unit using `to`. `months` and `years` are approximations
+* based on a 365-day year (no leap-year adjustment), so a "month" is
+* `365 / 12 ≈ 30.42` days — not a calendar month.
+*
+* @param amount - The numeric duration to convert.
+* @param options - Conversion options.
+* @param options.from - The unit `amount` is currently expressed in. Defaults to `'seconds'`.
+* @param options.to - The unit to convert `amount` into. Defaults to `'seconds'`.
+*
+* @returns `amount` expressed in the `to` unit.
+*
+* @example
+* // 90 seconds -> minutes
+* convertDuration(90, { from: 'seconds', to: 'minutes' }) // 1.5
+*
+* @example
+* // 3 hours -> milliseconds
+* convertDuration(3, { from: 'hours', to: 'milliseconds' }) // 10800000
+*
+* @example
+* // 2 weeks -> days
+* convertDuration(2, { from: 'weeks', to: 'days' }) // 14
+*
+* @example
+* // 18 months -> years (approximate, non-calendar months)
+* convertDuration(18, { from: 'months', to: 'years' }) // 1.5
+*/
+const convertDuration = (amount, { from = "seconds", to = "seconds" }) => {
+	return amount * millisecondsInUnit[from] / millisecondsInUnit[to];
+};
+//#endregion
+export { convertDuration };

package/dist/convertUnit.d.ts

@@ -0,0 +1,85 @@
+//#region src/convertUnit.d.ts
+declare const exponents: {
+  readonly unit: {
+    readonly si: 3;
+    readonly iec: 0;
+  };
+  readonly kilo: {
+    readonly si: 6;
+    readonly iec: 10;
+  };
+  readonly mega: {
+    readonly si: 9;
+    readonly iec: 20;
+  };
+  readonly giga: {
+    readonly si: 12;
+    readonly iec: 30;
+  };
+  readonly tera: {
+    readonly si: 15;
+    readonly iec: 40;
+  };
+  readonly peta: {
+    readonly si: 18;
+    readonly iec: 50;
+  };
+  readonly exa: {
+    readonly si: 21;
+    readonly iec: 60;
+  };
+  readonly zetta: {
+    readonly si: 24;
+    readonly iec: 70;
+  };
+  readonly yotta: {
+    readonly si: 27;
+    readonly iec: 80;
+  };
+};
+type Unit = keyof typeof exponents;
+type ConvertUnitArgs = {
+  from?: Unit;
+  to?: Unit;
+  base?: 2 | 10;
+};
+/**
+ * Converts a numeric amount from one unit prefix to another, using either
+ * SI (decimal, base 10) or IEC (binary, base 2) prefixes.
+ *
+ * The conversion is purely based on the exponent difference between `from`
+ * and `to` for the chosen base, so any pair of supported units can be
+ * converted directly in either direction (e.g. `mega` → `unit`, or
+ * `tera` → `giga`). This isn't limited to bytes/bits — any decimal-prefixed
+ * quantity (grams, meters, etc.) works the same way with `base: 10`.
+ *
+ * @see https://en.wikipedia.org/wiki/Binary_prefix
+ *
+ * @param amount - The numeric value to convert.
+ * @param options - Conversion options.
+ * @param options.from - Unit prefix of `amount`. Defaults to `'unit'` (no prefix).
+ * @param options.to - Unit prefix to convert `amount` into. Defaults to `'unit'` (no prefix).
+ * @param options.base - `10` for SI/decimal prefixes (1 kilo = 1000) or `2` for
+ *   IEC/binary prefixes (1 kilo = 1024). Defaults to `10`.
+ *
+ * @returns `amount` expressed in the `to` unit.
+ *
+ * @example
+ * // 1500 bytes -> kilobytes (decimal)
+ * convertUnit(1500, { from: 'unit', to: 'kilo' }) // 1.5
+ *
+ * @example
+ * // 2 mebibytes -> bytes (binary)
+ * convertUnit(2, { from: 'mega', to: 'unit', base: 2 }) // 2097152
+ *
+ * @example
+ * // 500 gigabytes -> terabytes (decimal)
+ * convertUnit(500, { from: 'giga', to: 'tera' }) // 0.5
+ *
+ * @example
+ * // 2.5 kilograms -> grams (decimal) — works for any SI quantity, not just data
+ * convertUnit(2.5, { from: 'kilo', to: 'unit' }) // 2500
+ */
+declare const convertUnit: (amount: number, { from, to, base }: ConvertUnitArgs) => number;
+//#endregion
+export { convertUnit };

package/dist/convertUnit.js

@@ -0,0 +1,83 @@
+//#region src/convertUnit.ts
+const exponents = {
+	unit: {
+		si: 3,
+		iec: 0
+	},
+	kilo: {
+		si: 6,
+		iec: 10
+	},
+	mega: {
+		si: 9,
+		iec: 20
+	},
+	giga: {
+		si: 12,
+		iec: 30
+	},
+	tera: {
+		si: 15,
+		iec: 40
+	},
+	peta: {
+		si: 18,
+		iec: 50
+	},
+	exa: {
+		si: 21,
+		iec: 60
+	},
+	zetta: {
+		si: 24,
+		iec: 70
+	},
+	yotta: {
+		si: 27,
+		iec: 80
+	}
+};
+/**
+* Converts a numeric amount from one unit prefix to another, using either
+* SI (decimal, base 10) or IEC (binary, base 2) prefixes.
+*
+* The conversion is purely based on the exponent difference between `from`
+* and `to` for the chosen base, so any pair of supported units can be
+* converted directly in either direction (e.g. `mega` → `unit`, or
+* `tera` → `giga`). This isn't limited to bytes/bits — any decimal-prefixed
+* quantity (grams, meters, etc.) works the same way with `base: 10`.
+*
+* @see https://en.wikipedia.org/wiki/Binary_prefix
+*
+* @param amount - The numeric value to convert.
+* @param options - Conversion options.
+* @param options.from - Unit prefix of `amount`. Defaults to `'unit'` (no prefix).
+* @param options.to - Unit prefix to convert `amount` into. Defaults to `'unit'` (no prefix).
+* @param options.base - `10` for SI/decimal prefixes (1 kilo = 1000) or `2` for
+*   IEC/binary prefixes (1 kilo = 1024). Defaults to `10`.
+*
+* @returns `amount` expressed in the `to` unit.
+*
+* @example
+* // 1500 bytes -> kilobytes (decimal)
+* convertUnit(1500, { from: 'unit', to: 'kilo' }) // 1.5
+*
+* @example
+* // 2 mebibytes -> bytes (binary)
+* convertUnit(2, { from: 'mega', to: 'unit', base: 2 }) // 2097152
+*
+* @example
+* // 500 gigabytes -> terabytes (decimal)
+* convertUnit(500, { from: 'giga', to: 'tera' }) // 0.5
+*
+* @example
+* // 2.5 kilograms -> grams (decimal) — works for any SI quantity, not just data
+* convertUnit(2.5, { from: 'kilo', to: 'unit' }) // 2500
+*/
+const convertUnit = (amount, { from = "unit", to = "unit", base = 10 }) => {
+	const prefix = base === 10 ? "si" : "iec";
+	const power = exponents[from][prefix] - exponents[to][prefix];
+	return amount * Math.pow(base, power);
+};
+//#endregion
+export { convertUnit };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { convertUnit } from "./convertUnit.js";
+import { convertDuration } from "./convertDuration.js";
+import { DAYS_IN_MONTH, DAYS_IN_WEEK, DAYS_IN_YEAR, HOURS_IN_DAY, HOURS_IN_MONTH, MONTHS_IN_YEAR, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH } from "./constants.js";
+export { DAYS_IN_MONTH, DAYS_IN_WEEK, DAYS_IN_YEAR, HOURS_IN_DAY, HOURS_IN_MONTH, MONTHS_IN_YEAR, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH, convertDuration, convertUnit };

package/dist/index.js

@@ -0,0 +1,4 @@
+import { convertUnit } from "./convertUnit.js";
+import { convertDuration } from "./convertDuration.js";
+import { DAYS_IN_MONTH, DAYS_IN_WEEK, DAYS_IN_YEAR, HOURS_IN_DAY, HOURS_IN_MONTH, MONTHS_IN_YEAR, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH } from "./constants.js";
+export { DAYS_IN_MONTH, DAYS_IN_WEEK, DAYS_IN_YEAR, HOURS_IN_DAY, HOURS_IN_MONTH, MONTHS_IN_YEAR, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, SECONDS_IN_MONTH, convertDuration, convertUnit };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@scaleway/units",
+  "version": "1.0.0",
+  "description": "Library to handle units and unit conversion",
+  "homepage": "https://github.com/scaleway/scaleway-lib/tree/main/packages/units",
+  "bugs": {
+    "url": "https://github.com/scaleway/scaleway-lib/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scaleway/scaleway-lib.git",
+    "directory": "packages/units"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsdown",
+    "test:unit": "vitest --run",
+    "test:unit:coverage": "pnpm test:unit --coverage"
+  }
+}