@naturalcycles/js-lib 15.86.2 → 15.88.0

package/dist/analytics/analytics.model.d.ts

@@ -0,0 +1,76 @@
+import type { AnyObject, Branded, StringMap, UnixTimestampMillis } from '../types.js';
+/** Identity an event is attributed to: a generated device id, or an app-provided user id. */
+export type AnalyticsDistinctId = Branded<string, 'AnalyticsDistinctId'>;
+/** Emitted when the identity changes, naming the anonymous id the events so far belong to. */
+export declare const ANALYTICS_IDENTIFY_EVENT_NAME = "identify";
+/** Cap applied by `truncateAnalyticsProperty`. Event properties are passed through as given. */
+export declare const MAX_ANALYTICS_PROPERTY_LENGTH = 255;
+/**
+ * Caps a string property at the limit. Counts code points, because a plain
+ * slice(0, N) counts UTF-16 code units and can cut a surrogate pair in half.
+ */
+export declare function truncateAnalyticsProperty(value: string): string;
+/**
+ * POST body of the ingestion endpoint - a client-batched analytics event envelope.
+ *
+ * Sent as a JSON string with `text/plain` content-type,
+ * to keep the request CORS-simple (no preflight).
+ */
+export interface AnalyticsBatchInput {
+    /**
+     * Client-side unix timestamp (ms) of when this request was sent.
+     * Kept as envelope timing metadata. It must not be used to adjust `event.ts`,
+     * because it changes between delivery attempts.
+     */
+    sentAt: UnixTimestampMillis;
+    /**
+     * Client that sends the events. Allow-listed by the destination.
+     */
+    clientId: number;
+    /**
+     * @deprecated Use `AnalyticsClientEvent.userId`, which is stamped when the event is tracked
+     * rather than when the batch is sent. Still sent for clients that predate the per-event id.
+     */
+    userId: AnalyticsDistinctId;
+    events: AnalyticsClientEvent[];
+}
+export interface AnalyticsClientEvent {
+    /**
+     * Unique event id, used for deduplication. Alphanumeric-only, so it can be
+     * forwarded as a dedupe key without conversion.
+     */
+    id: string;
+    /**
+     * Event name, e.g `WebClick`.
+     */
+    name: string;
+    /**
+     * Client-side unix timestamp (ms) of when the event was tracked (not when it was sent).
+     * Stable across delivery attempts, because a deduplication key may include it.
+     */
+    ts: UnixTimestampMillis;
+    /**
+     * Event properties.
+     */
+    props?: AnyObject;
+    /**
+     * Identity this event was tracked under
+     * TODO: make required
+     */
+    userId?: AnalyticsDistinctId;
+}
+/** Canonical utm parameters. */
+export declare const CANONICAL_UTM_PARAMS: string[];
+/** Keyed by `initial_<canonical utm param>`, to avoid permanently saving non-standard ones. */
+export type FirstTouchUtms = StringMap<string | null>;
+/**
+ * Properties that will be "set once" on a user profile. Meaning they are not changed by subsequent
+ * saves on the user profile. Keyed by `initial_referrer` and the first-touch utms.
+ */
+export type SetOnceUserProperties = StringMap<string | null>;
+/** Body of the first-touch endpoint, posted once per pageload. */
+export interface FirstTouchInput {
+    clientId: number;
+    userId: AnalyticsDistinctId;
+    props: SetOnceUserProperties;
+}

package/dist/analytics/analytics.model.js

@@ -0,0 +1,26 @@
+/** Emitted when the identity changes, naming the anonymous id the events so far belong to. */
+export const ANALYTICS_IDENTIFY_EVENT_NAME = 'identify';
+/** Cap applied by `truncateAnalyticsProperty`. Event properties are passed through as given. */
+export const MAX_ANALYTICS_PROPERTY_LENGTH = 255;
+/**
+ * Caps a string property at the limit. Counts code points, because a plain
+ * slice(0, N) counts UTF-16 code units and can cut a surrogate pair in half.
+ */
+export function truncateAnalyticsProperty(value) {
+    if (value.length <= MAX_ANALYTICS_PROPERTY_LENGTH)
+        return value;
+    return Array.from(value).slice(0, MAX_ANALYTICS_PROPERTY_LENGTH).join('');
+}
+/** Canonical utm parameters. */
+export const CANONICAL_UTM_PARAMS = [
+    'utm_source',
+    'utm_medium',
+    'utm_campaign',
+    'utm_content',
+    'utm_term',
+    'utm_id',
+    'utm_source_platform',
+    'utm_campaign_id',
+    'utm_creative_format',
+    'utm_marketing_tactic',
+];

package/dist/analytics/index.d.ts

@@ -0,0 +1 @@
+export * from './analytics.model.js';

package/dist/analytics/index.js

@@ -0,0 +1 @@
+export * from './analytics.model.js';

package/dist/datetime/localDate.js

@@ -21,7 +21,11 @@ export class LocalDate {
         this.day = day;
     }
     get(unit) {
-        return unit === 'year' ? this.year : unit === 'month' ? this.month : this.day;
+        if (unit === 'year')
+            return this.year;
+        if (unit === 'month')
+            return this.month;
+        return this.day;
     }
     set(unit, v, opt = {}) {
         const t = opt.mutate ? this : this.clone();

package/dist/enum.util.d.ts

@@ -1,4 +1,32 @@
-import type { AnyObject, NumberEnum, StringEnum } from './types.js';
+import type { AnyObject, Enum, NumberEnum, StringEnum } from './types.js';
+/**
+ * Creates a runtime Enum object. A replacement for a native TypeScript enum,
+ * which is not supported by type-stripping runtimes (e.g `node --experimental-strip-types`).
+ *
+ * Declare the type with the same name as the const, to mimic how native enums merge value and type.
+ *
+ * @example
+ * export const Color = _enum({ RED: 'red', GREEN: 'green' })
+ * export type Color = typeof Color.type // 'red' | 'green'
+ *
+ * Color.RED // 'red'
+ * Color.keys // ['RED', 'GREEN']
+ * Color.values // ['red', 'green']
+ * Color.entries // [['RED', 'red'], ['GREEN', 'green']]
+ * Color.is(x) // type-guard for 'red' | 'green'
+ * Color.keyOf('red') // 'RED'
+ * JSON.stringify(Color) // '{"RED":"red","GREEN":"green"}', no reverse-mapping, no helper leakage
+ *
+ * The result doesn't satisfy `StringEnum`/`NumberEnum`, so the `_stringEnum*`/`_numberEnum*`
+ * functions don't accept it. Use the helpers on the returned object instead.
+ *
+ * Nothing is frozen, immutability is expressed through `readonly` types only.
+ *
+ * Throws if the input contains a key that collides with one of the helper names.
+ *
+ * @experimental
+ */
+export declare function _enum<const T extends Record<string, string> | Record<string, number>>(obj: T): EnumObject<T>;
 export declare function getEnumType(en: AnyObject): 'StringEnum' | 'NumberEnum' | undefined;
 /**
  * Returns all String keys of a number-enum.
@@ -91,3 +119,51 @@ export declare function _numberEnumKeyOrUndefined<T extends NumberEnum>(en: T, v
 export declare function _numberEnumKey<T extends NumberEnum>(en: T, v: T[keyof T] | undefined | null): keyof T;
 export declare function _stringEnumKeyOrUndefined<T extends StringEnum>(en: T, v: string | undefined | null): keyof T | undefined;
 export declare function _stringEnumKey<T extends StringEnum>(en: T, v: string | undefined | null): keyof T;
+/**
+ * @experimental
+ */
+export type EnumObject<T> = Readonly<T> & EnumHelpers<T>;
+/**
+ * Helpers that `_enum()` hangs off the returned object.
+ * Defined as non-enumerable, so that `Object.keys/values/entries`, `JSON.stringify`
+ * and `for..in` still only see the actual Enum members.
+ *
+ * `keys`/`values`/`entries` are precomputed, and keep the literal types
+ * that the `Object.*` equivalents would widen to `string`.
+ *
+ * @experimental
+ */
+interface EnumHelpers<T> {
+    /**
+     * Type-only carrier for the union of all values, so that the Enum's type can be declared
+     * without a second import: `export type Color = typeof Color.type`.
+     *
+     * It has no runtime counterpart, reading it as a value returns undefined.
+     */
+    readonly type: Enum<T>;
+    readonly keys: readonly (keyof T)[];
+    readonly values: readonly Enum<T>[];
+    readonly entries: EnumEntries<T>;
+    /**
+     * Type-guard. O(1), backed by a Map.
+     */
+    readonly is: (v: unknown) => v is Enum<T>;
+    /**
+     * Reverse lookup, the counterpart of `Color.RED`. O(1). Throws if the value is not a member.
+     */
+    readonly keyOf: (v: Enum<T>) => keyof T;
+    /**
+     * Like `keyOf`, but takes untrusted input and returns undefined instead of throwing.
+     */
+    readonly keyOfOrUndefined: (v: unknown) => keyof T | undefined;
+}
+/**
+ * The mapped type (rather than `readonly [keyof T, Enum<T>][]`) keeps each key paired
+ * with its own value, instead of allowing any key/value combination.
+ *
+ * @experimental
+ */
+type EnumEntries<T> = readonly {
+    [K in keyof T]: readonly [k: K, v: T[K]];
+}[keyof T][];
+export {};

package/dist/enum.util.js

@@ -1,3 +1,68 @@
+/**
+ * Creates a runtime Enum object. A replacement for a native TypeScript enum,
+ * which is not supported by type-stripping runtimes (e.g `node --experimental-strip-types`).
+ *
+ * Declare the type with the same name as the const, to mimic how native enums merge value and type.
+ *
+ * @example
+ * export const Color = _enum({ RED: 'red', GREEN: 'green' })
+ * export type Color = typeof Color.type // 'red' | 'green'
+ *
+ * Color.RED // 'red'
+ * Color.keys // ['RED', 'GREEN']
+ * Color.values // ['red', 'green']
+ * Color.entries // [['RED', 'red'], ['GREEN', 'green']]
+ * Color.is(x) // type-guard for 'red' | 'green'
+ * Color.keyOf('red') // 'RED'
+ * JSON.stringify(Color) // '{"RED":"red","GREEN":"green"}', no reverse-mapping, no helper leakage
+ *
+ * The result doesn't satisfy `StringEnum`/`NumberEnum`, so the `_stringEnum*`/`_numberEnum*`
+ * functions don't accept it. Use the helpers on the returned object instead.
+ *
+ * Nothing is frozen, immutability is expressed through `readonly` types only.
+ *
+ * Throws if the input contains a key that collides with one of the helper names.
+ *
+ * @experimental
+ */
+export function _enum(obj) {
+    if (RESERVED_KEYS.some(k => Object.hasOwn(obj, k))) {
+        throw new Error(`_enum keys must not be named ${RESERVED_KEYS.join(', ')}, as they collide with the helpers`);
+    }
+    const rawEntries = Object.entries(obj);
+    const keys = Object.keys(obj);
+    const values = Object.values(obj);
+    const entries = rawEntries;
+    // Backs both `is` and `keyOf`. On duplicate values the last key wins, like a native number enum.
+    const keyByValue = new Map(rawEntries.map(([k, v]) => [v, k]));
+    return Object.defineProperties({ ...obj }, {
+        keys: { value: keys },
+        values: { value: values },
+        entries: { value: entries },
+        is: { value: (v) => keyByValue.has(v) },
+        keyOf: {
+            value: (v) => {
+                const key = keyByValue.get(v);
+                if (key === undefined)
+                    throw new Error(`_enum keyOf not found for: ${String(v)}`);
+                return key;
+            },
+        },
+        keyOfOrUndefined: { value: (v) => keyByValue.get(v) },
+    });
+}
+/**
+ * Keys that `_enum()` reserves for its helpers, and therefore rejects as Enum member names.
+ */
+const RESERVED_KEYS = [
+    'type',
+    'keys',
+    'values',
+    'entries',
+    'is',
+    'keyOf',
+    'keyOfOrUndefined',
+];
 export function getEnumType(en) {
     /*
      * enum Foo { A = 1, B = 2 }

package/dist/number/number.util.js

@@ -40,7 +40,11 @@ export function _isBetween(x, min, max, incl) {
     return true;
 }
 export function _clamp(x, minIncl, maxIncl) {
-    return x <= minIncl ? minIncl : x >= maxIncl ? maxIncl : x;
+    if (x <= minIncl)
+        return minIncl;
+    if (x >= maxIncl)
+        return maxIncl;
+    return x;
 }
 /**
  * Same as .toFixed(), but conveniently casts the output to Number.

package/dist/qr/qr.js

@@ -560,8 +560,11 @@ function getLengthInBits(mode, type) {
     const bits = LENGTH_BITS[mode];
     if (!bits)
         throw new Error(`qr: bad mode: ${mode}`);
-    const range = type < 10 ? 0 : type < 27 ? 1 : 2;
-    return bits[range];
+    if (type < 10)
+        return bits[0];
+    if (type < 27)
+        return bits[1];
+    return bits[2];
 }
 // --- Reed-Solomon polynomials over GF(256) ---------------------------------
 /** Drop leading zeros, then right-pad with `shift` zeros. */

package/dist/semver.js

@@ -147,5 +147,9 @@ export function _quickSemverCompare(a, b) {
     const s2 = _range(3)
         .map(i => (t2[i] || '').padStart(5))
         .join('');
-    return s1 < s2 ? -1 : s1 > s2 ? 1 : 0;
+    if (s1 < s2)
+        return -1;
+    if (s1 > s2)
+        return 1;
+    return 0;
 }

package/dist/string/leven.js

@@ -63,14 +63,13 @@ export function _leven(first, second, limit) {
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];
-            result = array[index] =
-                temporary > result
-                    ? temporary2 > result
-                        ? result + 1
-                        : temporary2
-                    : temporary2 > temporary
-                        ? temporary + 1
-                        : temporary2;
+            if (temporary > result) {
+                result = temporary2 > result ? result + 1 : temporary2;
+            }
+            else {
+                result = temporary2 > temporary ? temporary + 1 : temporary2;
+            }
+            array[index] = result;
         }
     }
     return result;

package/dist/types.d.ts

@@ -28,6 +28,20 @@ export type AnyObject = Record<string, any>;
 export type AnyEnum = NumberEnum;
 export type NumberEnum = Record<string, number | string>;
 export type StringEnum = Record<string, string>;
+/**
+ * Union of all values of an Enum-like object: both native TypeScript enums and `_enum()` objects.
+ *
+ * For an `_enum()` object prefer `typeof Color.type`, which needs no import.
+ *
+ * @example
+ * enum Color { RED = 'red', GREEN = 'green' }
+ * type ColorValue = Enum<typeof Color> // 'red' | 'green'
+ *
+ * @experimental
+ */
+export type Enum<T> = T extends {
+    values: readonly (infer V)[];
+} ? V : T[keyof T];
 export type CreatedUpdated = {
     created: UnixTimestamp;
     updated: UnixTimestamp;

package/dist/ua/ua.d.ts

@@ -152,7 +152,7 @@ export declare class UAParser {
     getOS(): UAOS;
     getResult(): UAResult;
     getUA(): string;
-    setUA(ua: string | undefined): this;
+    setUA(ua?: string | undefined): this;
     /**
      * True if the OS is iOS.
      * Note: desktop-mode iPads send a Mac-like UA and are not detected as iOS

package/dist/ua/ua.js

@@ -146,8 +146,7 @@ export class UAParser {
     getUA() {
         return this.ua;
     }
-    setUA(ua) {
-        ua ||= '';
+    setUA(ua = '') {
         this.ua = ua.length > UA_MAX_LENGTH ? ua.replace(/^\s\s*/, '').slice(0, UA_MAX_LENGTH) : ua;
         this.cachedBrowser = this.cachedOs = this.cachedDevice = undefined;
         return this;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.86.2",
+  "version": "15.88.0",
   "dependencies": {
     "tslib": "^2"
   },
@@ -22,6 +22,8 @@
   },
   "exports": {
     ".": "./dist/index.js",
+    "./analytics": "./dist/analytics/index.js",
+    "./analytics/*.js": "./dist/analytics/*.js",
     "./array": "./dist/array/index.js",
     "./array/*.js": "./dist/array/*.js",
     "./browser": "./dist/browser/index.js",

package/src/analytics/analytics.model.ts

@@ -0,0 +1,100 @@
+import type { AnyObject, Branded, StringMap, UnixTimestampMillis } from '../types.js'
+
+/** Identity an event is attributed to: a generated device id, or an app-provided user id. */
+export type AnalyticsDistinctId = Branded<string, 'AnalyticsDistinctId'>
+
+/** Emitted when the identity changes, naming the anonymous id the events so far belong to. */
+export const ANALYTICS_IDENTIFY_EVENT_NAME = 'identify'
+
+/** Cap applied by `truncateAnalyticsProperty`. Event properties are passed through as given. */
+export const MAX_ANALYTICS_PROPERTY_LENGTH = 255
+
+/**
+ * Caps a string property at the limit. Counts code points, because a plain
+ * slice(0, N) counts UTF-16 code units and can cut a surrogate pair in half.
+ */
+export function truncateAnalyticsProperty(value: string): string {
+  if (value.length <= MAX_ANALYTICS_PROPERTY_LENGTH) return value
+  return Array.from(value).slice(0, MAX_ANALYTICS_PROPERTY_LENGTH).join('')
+}
+
+/**
+ * POST body of the ingestion endpoint - a client-batched analytics event envelope.
+ *
+ * Sent as a JSON string with `text/plain` content-type,
+ * to keep the request CORS-simple (no preflight).
+ */
+export interface AnalyticsBatchInput {
+  /**
+   * Client-side unix timestamp (ms) of when this request was sent.
+   * Kept as envelope timing metadata. It must not be used to adjust `event.ts`,
+   * because it changes between delivery attempts.
+   */
+  sentAt: UnixTimestampMillis
+  /**
+   * Client that sends the events. Allow-listed by the destination.
+   */
+  clientId: number
+  /**
+   * @deprecated Use `AnalyticsClientEvent.userId`, which is stamped when the event is tracked
+   * rather than when the batch is sent. Still sent for clients that predate the per-event id.
+   */
+  userId: AnalyticsDistinctId
+  events: AnalyticsClientEvent[]
+}
+
+export interface AnalyticsClientEvent {
+  /**
+   * Unique event id, used for deduplication. Alphanumeric-only, so it can be
+   * forwarded as a dedupe key without conversion.
+   */
+  id: string
+  /**
+   * Event name, e.g `WebClick`.
+   */
+  name: string
+  /**
+   * Client-side unix timestamp (ms) of when the event was tracked (not when it was sent).
+   * Stable across delivery attempts, because a deduplication key may include it.
+   */
+  ts: UnixTimestampMillis
+  /**
+   * Event properties.
+   */
+  props?: AnyObject
+  /**
+   * Identity this event was tracked under
+   * TODO: make required
+   */
+  userId?: AnalyticsDistinctId
+}
+
+/** Canonical utm parameters. */
+export const CANONICAL_UTM_PARAMS = [
+  'utm_source',
+  'utm_medium',
+  'utm_campaign',
+  'utm_content',
+  'utm_term',
+  'utm_id',
+  'utm_source_platform',
+  'utm_campaign_id',
+  'utm_creative_format',
+  'utm_marketing_tactic',
+]
+
+/** Keyed by `initial_<canonical utm param>`, to avoid permanently saving non-standard ones. */
+export type FirstTouchUtms = StringMap<string | null>
+
+/**
+ * Properties that will be "set once" on a user profile. Meaning they are not changed by subsequent
+ * saves on the user profile. Keyed by `initial_referrer` and the first-touch utms.
+ */
+export type SetOnceUserProperties = StringMap<string | null>
+
+/** Body of the first-touch endpoint, posted once per pageload. */
+export interface FirstTouchInput {
+  clientId: number
+  userId: AnalyticsDistinctId
+  props: SetOnceUserProperties
+}

package/src/analytics/index.ts

@@ -0,0 +1 @@
+export * from './analytics.model.js'

package/src/datetime/localDate.ts

@@ -40,7 +40,9 @@ export class LocalDate {
   ) {}
 
   get(unit: LocalDateUnitStrict): number {
-    return unit === 'year' ? this.year : unit === 'month' ? this.month : this.day
+    if (unit === 'year') return this.year
+    if (unit === 'month') return this.month
+    return this.day
   }
 
   set(unit: LocalDateUnitStrict, v: number, opt: MutateOptions = {}): LocalDate {

package/src/enum.util.ts

@@ -1,4 +1,79 @@
-import type { AnyObject, NumberEnum, StringEnum } from './types.js'
+import type { AnyObject, Enum, NumberEnum, StringEnum } from './types.js'
+
+/**
+ * Creates a runtime Enum object. A replacement for a native TypeScript enum,
+ * which is not supported by type-stripping runtimes (e.g `node --experimental-strip-types`).
+ *
+ * Declare the type with the same name as the const, to mimic how native enums merge value and type.
+ *
+ * @example
+ * export const Color = _enum({ RED: 'red', GREEN: 'green' })
+ * export type Color = typeof Color.type // 'red' | 'green'
+ *
+ * Color.RED // 'red'
+ * Color.keys // ['RED', 'GREEN']
+ * Color.values // ['red', 'green']
+ * Color.entries // [['RED', 'red'], ['GREEN', 'green']]
+ * Color.is(x) // type-guard for 'red' | 'green'
+ * Color.keyOf('red') // 'RED'
+ * JSON.stringify(Color) // '{"RED":"red","GREEN":"green"}', no reverse-mapping, no helper leakage
+ *
+ * The result doesn't satisfy `StringEnum`/`NumberEnum`, so the `_stringEnum*`/`_numberEnum*`
+ * functions don't accept it. Use the helpers on the returned object instead.
+ *
+ * Nothing is frozen, immutability is expressed through `readonly` types only.
+ *
+ * Throws if the input contains a key that collides with one of the helper names.
+ *
+ * @experimental
+ */
+export function _enum<const T extends Record<string, string> | Record<string, number>>(
+  obj: T,
+): EnumObject<T> {
+  if (RESERVED_KEYS.some(k => Object.hasOwn(obj, k))) {
+    throw new Error(
+      `_enum keys must not be named ${RESERVED_KEYS.join(', ')}, as they collide with the helpers`,
+    )
+  }
+
+  const rawEntries = Object.entries(obj)
+  const keys = Object.keys(obj) as (keyof T)[]
+  const values = Object.values(obj) as Enum<T>[]
+  const entries = rawEntries as unknown as EnumEntries<T>
+  // Backs both `is` and `keyOf`. On duplicate values the last key wins, like a native number enum.
+  const keyByValue = new Map<unknown, keyof T>(rawEntries.map(([k, v]) => [v, k]))
+
+  return Object.defineProperties(
+    { ...obj },
+    {
+      keys: { value: keys },
+      values: { value: values },
+      entries: { value: entries },
+      is: { value: (v: unknown): v is Enum<T> => keyByValue.has(v) },
+      keyOf: {
+        value: (v: Enum<T>): keyof T => {
+          const key = keyByValue.get(v)
+          if (key === undefined) throw new Error(`_enum keyOf not found for: ${String(v)}`)
+          return key
+        },
+      },
+      keyOfOrUndefined: { value: (v: unknown): keyof T | undefined => keyByValue.get(v) },
+    },
+  ) as EnumObject<T>
+}
+
+/**
+ * Keys that `_enum()` reserves for its helpers, and therefore rejects as Enum member names.
+ */
+const RESERVED_KEYS = [
+  'type',
+  'keys',
+  'values',
+  'entries',
+  'is',
+  'keyOf',
+  'keyOfOrUndefined',
+] as const
 
 export function getEnumType(en: AnyObject): 'StringEnum' | 'NumberEnum' | undefined {
   /*
@@ -226,3 +301,51 @@ export function _stringEnumKey<T extends StringEnum>(en: T, v: string | undefine
   if (!r) throw new Error(`_stringEnumKey not found for: ${v}`)
   return r
 }
+
+/**
+ * @experimental
+ */
+export type EnumObject<T> = Readonly<T> & EnumHelpers<T>
+
+/**
+ * Helpers that `_enum()` hangs off the returned object.
+ * Defined as non-enumerable, so that `Object.keys/values/entries`, `JSON.stringify`
+ * and `for..in` still only see the actual Enum members.
+ *
+ * `keys`/`values`/`entries` are precomputed, and keep the literal types
+ * that the `Object.*` equivalents would widen to `string`.
+ *
+ * @experimental
+ */
+interface EnumHelpers<T> {
+  /**
+   * Type-only carrier for the union of all values, so that the Enum's type can be declared
+   * without a second import: `export type Color = typeof Color.type`.
+   *
+   * It has no runtime counterpart, reading it as a value returns undefined.
+   */
+  readonly type: Enum<T>
+  readonly keys: readonly (keyof T)[]
+  readonly values: readonly Enum<T>[]
+  readonly entries: EnumEntries<T>
+  /**
+   * Type-guard. O(1), backed by a Map.
+   */
+  readonly is: (v: unknown) => v is Enum<T>
+  /**
+   * Reverse lookup, the counterpart of `Color.RED`. O(1). Throws if the value is not a member.
+   */
+  readonly keyOf: (v: Enum<T>) => keyof T
+  /**
+   * Like `keyOf`, but takes untrusted input and returns undefined instead of throwing.
+   */
+  readonly keyOfOrUndefined: (v: unknown) => keyof T | undefined
+}
+
+/**
+ * The mapped type (rather than `readonly [keyof T, Enum<T>][]`) keeps each key paired
+ * with its own value, instead of allowing any key/value combination.
+ *
+ * @experimental
+ */
+type EnumEntries<T> = readonly { [K in keyof T]: readonly [k: K, v: T[K]] }[keyof T][]

package/src/number/number.util.ts

@@ -50,7 +50,9 @@ export function _isBetween<T extends number | string>(
 }
 
 export function _clamp(x: number, minIncl: number, maxIncl: number): number {
-  return x <= minIncl ? minIncl : x >= maxIncl ? maxIncl : x
+  if (x <= minIncl) return minIncl
+  if (x >= maxIncl) return maxIncl
+  return x
 }
 
 /**

package/src/qr/qr.ts

@@ -684,8 +684,9 @@ function getLengthInBits(mode: number, type: number): number {
   if (type < 1 || type > 40) throw new Error(`qr: bad type number: ${type}`)
   const bits = LENGTH_BITS[mode]
   if (!bits) throw new Error(`qr: bad mode: ${mode}`)
-  const range = type < 10 ? 0 : type < 27 ? 1 : 2
-  return bits[range]
+  if (type < 10) return bits[0]
+  if (type < 27) return bits[1]
+  return bits[2]
 }
 
 // --- Reed-Solomon polynomials over GF(256) ---------------------------------

package/src/semver.ts

@@ -171,5 +171,7 @@ export function _quickSemverCompare(a: string, b: string): -1 | 0 | 1 {
   const s2 = _range(3)
     .map(i => (t2[i] || '').padStart(5))
     .join('')
-  return s1 < s2 ? -1 : s1 > s2 ? 1 : 0
+  if (s1 < s2) return -1
+  if (s1 > s2) return 1
+  return 0
 }

package/src/string/leven.ts

@@ -76,14 +76,12 @@ export function _leven(first: string, second: string, limit?: number): number {
       temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1
       temporary = array[index]!
 
-      result = array[index] =
-        temporary > result
-          ? temporary2 > result
-            ? result + 1
-            : temporary2
-          : temporary2 > temporary
-            ? temporary + 1
-            : temporary2
+      if (temporary > result) {
+        result = temporary2 > result ? result + 1 : temporary2
+      } else {
+        result = temporary2 > temporary ? temporary + 1 : temporary2
+      }
+      array[index] = result
     }
   }
 

package/src/types.ts

@@ -34,6 +34,21 @@ export type AnyEnum = NumberEnum
 export type NumberEnum = Record<string, number | string>
 export type StringEnum = Record<string, string>
 
+/**
+ * Union of all values of an Enum-like object: both native TypeScript enums and `_enum()` objects.
+ *
+ * For an `_enum()` object prefer `typeof Color.type`, which needs no import.
+ *
+ * @example
+ * enum Color { RED = 'red', GREEN = 'green' }
+ * type ColorValue = Enum<typeof Color> // 'red' | 'green'
+ *
+ * @experimental
+ */
+// The first branch is for `_enum()` objects, whose helpers `T[keyof T]` would otherwise pull into
+// the union. Native enums never match it, since their values are `string | number`, never an array.
+export type Enum<T> = T extends { values: readonly (infer V)[] } ? V : T[keyof T]
+
 // oxlint-disable-next-line @typescript-eslint/consistent-type-definitions
 export type CreatedUpdated = {
   created: UnixTimestamp

package/src/ua/ua.ts

@@ -266,8 +266,7 @@ export class UAParser {
     return this.ua
   }
 
-  setUA(ua: string | undefined): this {
-    ua ||= ''
+  setUA(ua: string | undefined = ''): this {
     this.ua = ua.length > UA_MAX_LENGTH ? ua.replace(/^\s\s*/, '').slice(0, UA_MAX_LENGTH) : ua
     this.cachedBrowser = this.cachedOs = this.cachedDevice = undefined
     return this