@socketsecurity/lib 5.19.1 → 5.21.0

package/dist/promise-queue.d.ts

@@ -1,8 +1,9 @@
 /**
  * @fileoverview Bounded concurrency promise queue.
  * Exports the `PromiseQueue` class, which limits how many async tasks run
- * simultaneously, supports an optional max queue length (dropping the oldest
- * pending task when exceeded), and exposes an idle-wait helper.
+ * simultaneously, supports an optional max queue length (new tasks beyond
+ * the cap are rejected with "Task dropped: queue length exceeded"), and
+ * exposes an idle-wait helper.
  */
 export declare class PromiseQueue {
     private queue;
@@ -13,13 +14,17 @@ export declare class PromiseQueue {
     /**
      * Creates a new PromiseQueue
      * @param maxConcurrency - Maximum number of promises that can run concurrently
-     * @param maxQueueLength - Maximum queue size (older tasks are dropped if exceeded)
+     * @param maxQueueLength - Maximum queue size; submissions past the cap
+     * reject with "Task dropped: queue length exceeded" instead of evicting
+     * a caller that has been waiting patiently. Callers must handle this
+     * rejection or they'll see an unhandled rejection.
      */
     constructor(maxConcurrency: number, maxQueueLength?: number | undefined);
     /**
      * Add a task to the queue
      * @param fn - Async function to execute
-     * @returns Promise that resolves with the function's result
+     * @returns Promise that resolves with the function's result, or rejects
+     * with "Task dropped: queue length exceeded" if the queue is full.
      */
     add<T>(fn: () => Promise<T>): Promise<T>;
     private runNext;

package/dist/promise-queue.js

@@ -32,7 +32,10 @@ class PromiseQueue {
   /**
    * Creates a new PromiseQueue
    * @param maxConcurrency - Maximum number of promises that can run concurrently
-   * @param maxQueueLength - Maximum queue size (older tasks are dropped if exceeded)
+   * @param maxQueueLength - Maximum queue size; submissions past the cap
+   * reject with "Task dropped: queue length exceeded" instead of evicting
+   * a caller that has been waiting patiently. Callers must handle this
+   * rejection or they'll see an unhandled rejection.
    */
   constructor(maxConcurrency, maxQueueLength) {
     this.maxConcurrency = maxConcurrency;
@@ -44,17 +47,16 @@ class PromiseQueue {
   /**
    * Add a task to the queue
    * @param fn - Async function to execute
-   * @returns Promise that resolves with the function's result
+   * @returns Promise that resolves with the function's result, or rejects
+   * with "Task dropped: queue length exceeded" if the queue is full.
    */
   async add(fn) {
     return await new Promise((resolve, reject) => {
-      const task = { fn, resolve, reject };
       if (this.maxQueueLength !== void 0 && this.queue.length >= this.maxQueueLength) {
-        const droppedTask = this.queue.shift();
-        if (droppedTask) {
-          droppedTask.reject(new Error("Task dropped: queue length exceeded"));
-        }
+        reject(new Error("Task dropped: queue length exceeded"));
+        return;
       }
+      const task = { fn, resolve, reject };
       this.queue.push(task);
       this.runNext();
     });
@@ -69,7 +71,7 @@ class PromiseQueue {
       return;
     }
     this.running++;
-    task.fn().then(task.resolve).catch(task.reject).finally(() => {
+    Promise.resolve().then(() => task.fn()).then(task.resolve).catch(task.reject).finally(() => {
       this.running--;
       this.runNext();
     });

package/dist/promises.d.ts

@@ -440,3 +440,44 @@ export declare function pRetry<T>(callbackFn: (...args: unknown[]) => Promise<T>
  * // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }
  */
 export declare function resolveRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;
+/**
+ * Shape returned by {@link withResolvers}: a fresh pending promise plus
+ * the `resolve` / `reject` handles that settle it.
+ *
+ * Matches the spec return-shape exactly
+ * ([ECMA-262 §27.2.4.9](https://tc39.es/ecma262/#sec-promise.withResolvers)).
+ */
+export interface PromiseWithResolvers<T> {
+    /** The pending promise. */
+    promise: Promise<T>;
+    /** Resolves {@link promise} with the given value (or thenable). */
+    resolve: (value: T | PromiseLike<T>) => void;
+    /** Rejects {@link promise} with the given reason. */
+    reject: (reason?: unknown) => void;
+}
+/**
+ * Create a pending promise together with its `resolve` and `reject`
+ * handles as first-class values, per
+ * [ECMA-262 §27.2.4.9](https://tc39.es/ecma262/#sec-promise.withResolvers).
+ *
+ * Bound to native `Promise.withResolvers` when available (Node 20.12+ /
+ * 21+ / 22+; V8 ≥ 12.0); otherwise falls back to a spec-equivalent
+ * `new Promise(executor)` implementation that captures the handles via
+ * closure. The returned object always has own data properties `promise`,
+ * `resolve`, `reject` on `Object.prototype` — writable, enumerable, and
+ * configurable — matching the spec's `CreateDataPropertyOrThrow` steps.
+ *
+ * Use this instead of the manual
+ * `let resolve; const p = new Promise(r => { resolve = r })` dance for
+ * deferred-resolution patterns (event-driven bridges, adapter layers,
+ * handshake signaling) where the settle path lives outside the executor.
+ *
+ * @example
+ * ```typescript
+ * const { promise, resolve, reject } = withResolvers<string>()
+ * emitter.once('ready', () => resolve('ok'))
+ * emitter.once('error', err => reject(err))
+ * const result = await promise
+ * ```
+ */
+export declare const withResolvers: <T>() => PromiseWithResolvers<T>;

package/dist/promises.js

@@ -27,7 +27,8 @@ __export(promises_exports, {
   pFilter: () => pFilter,
   pFilterChunk: () => pFilterChunk,
   pRetry: () => pRetry,
-  resolveRetryOptions: () => resolveRetryOptions
+  resolveRetryOptions: () => resolveRetryOptions,
+  withResolvers: () => withResolvers
 });
 module.exports = __toCommonJS(promises_exports);
 var import_arrays = require("./arrays");
@@ -258,6 +259,21 @@ function resolveRetryOptions(options) {
   }
   return options ? { ...defaults, ...options } : defaults;
 }
+const maybeNativeWithResolvers = Promise.withResolvers;
+const withResolvers = typeof maybeNativeWithResolvers === "function" ? (
+  // Bind so callers who destructure the export don't lose `this`.
+  maybeNativeWithResolvers.bind(
+    Promise
+  )
+) : () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   normalizeIterationOptions,
@@ -267,5 +283,6 @@ function resolveRetryOptions(options) {
   pFilter,
   pFilterChunk,
   pRetry,
-  resolveRetryOptions
+  resolveRetryOptions,
+  withResolvers
 });

package/dist/regexps.d.ts

@@ -1,15 +1,6 @@
 /**
- * @fileoverview Regular expression utilities including escape-string-regexp implementation.
- * Provides regex escaping and pattern matching helpers.
+ * @fileoverview Regular expression utilities including a spec-compliant
+ * `RegExp.escape` fallback. Provides regex escaping and pattern matching
+ * helpers.
  */
-/**
- * Escape special characters in a string for use in a regular expression.
- *
- * @example
- * ```typescript
- * escapeRegExp('foo.bar')     // 'foo\\.bar'
- * escapeRegExp('a+b*c?')     // 'a\\+b\\*c\\?'
- * new RegExp(escapeRegExp('[test]'))  // /\[test\]/
- * ```
- */
-export declare function escapeRegExp(str: string): string;
+export declare const escapeRegExp: (str: string) => string;

package/dist/regexps.js

@@ -23,10 +23,67 @@ __export(regexps_exports, {
   escapeRegExp: () => escapeRegExp
 });
 module.exports = __toCommonJS(regexps_exports);
-// @__NO_SIDE_EFFECTS__
-function escapeRegExp(str) {
-  return str.replace(/[\\|{}()[\]^$+*?.]/g, "\\$&");
+const SYNTAX_CHARACTERS = new Set("^$\\.*+?()[]{}|/");
+const CONTROL_ESCAPES = /* @__PURE__ */ new Map([
+  [9, "\\t"],
+  [10, "\\n"],
+  [11, "\\v"],
+  [12, "\\f"],
+  [13, "\\r"]
+]);
+const OTHER_PUNCTUATORS = new Set(",-=<>#&!%:;@~'`\"");
+function isSpecHexEscapeCp(cp) {
+  if (OTHER_PUNCTUATORS.has(String.fromCodePoint(cp))) {
+    return true;
+  }
+  if (cp === 10 || cp === 13 || cp === 8232 || cp === 8233) {
+    return true;
+  }
+  if (cp === 9 || cp === 11 || cp === 12 || cp === 32 || cp === 160 || cp === 65279) {
+    return true;
+  }
+  if (cp >= 55296 && cp <= 57343) {
+    return true;
+  }
+  return false;
+}
+function hex2(n) {
+  return n.toString(16).padStart(2, "0");
+}
+function hex4(n) {
+  return n.toString(16).padStart(4, "0");
+}
+function escapeRegExpFallback(str) {
+  let out = "";
+  let isFirst = true;
+  for (const char of str) {
+    const cp = char.codePointAt(0);
+    if (isFirst && (cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122)) {
+      out += "\\x" + hex2(cp);
+    } else if (SYNTAX_CHARACTERS.has(char)) {
+      out += "\\" + char;
+    } else {
+      const ctrl = CONTROL_ESCAPES.get(cp);
+      if (ctrl !== void 0) {
+        out += ctrl;
+      } else if (isSpecHexEscapeCp(cp)) {
+        if (cp <= 255) {
+          out += "\\x" + hex2(cp);
+        } else {
+          for (let i = 0; i < char.length; i++) {
+            out += "\\u" + hex4(char.charCodeAt(i));
+          }
+        }
+      } else {
+        out += char;
+      }
+    }
+    isFirst = false;
+  }
+  return out;
 }
+const maybeNativeEscape = RegExp.escape;
+const escapeRegExp = typeof maybeNativeEscape === "function" ? maybeNativeEscape : escapeRegExpFallback;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   escapeRegExp

package/dist/schema/parse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Throwing twin of `validateSchema`.
+ *
+ * Use `parseSchema(schema, data)` for fail-fast trust boundaries (app
+ * startup, config files, internal assertions). Use the non-throwing
+ * `validateSchema` for recoverable input (form fields, API request bodies,
+ * anywhere errors need to surface to a user).
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ * import { parseSchema } from '@socketsecurity/lib/schema/parse'
+ *
+ * const Config = z.object({ host: z.string(), port: z.number() })
+ * const config = parseSchema(Config, json)  // throws on invalid
+ * ```
+ */
+import type { Infer } from './types';
+/**
+ * Parse `data` against `schema` and return the validated value.
+ *
+ * @throws {Error} When validation fails. The message lists all issues as
+ *   `path: message, path: message, ...`. Use `validateSchema` if you need
+ *   structured access to the error list.
+ */
+export declare function parseSchema<S>(schema: S, data: unknown): Infer<S>;

package/dist/{zod.js → schema/parse.js}

@@ -18,13 +18,21 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var zod_exports = {};
-__export(zod_exports, {
-  z: () => import_zod.z
+var parse_exports = {};
+__export(parse_exports, {
+  parseSchema: () => parseSchema
 });
-module.exports = __toCommonJS(zod_exports);
-var import_zod = require("./external/zod");
+module.exports = __toCommonJS(parse_exports);
+var import_validate = require("./validate");
+function parseSchema(schema, data) {
+  const result = (0, import_validate.validateSchema)(schema, data);
+  if (result.ok) {
+    return result.value;
+  }
+  const summary = result.errors.map((e) => `${e.path.join(".") || "(root)"}: ${e.message}`).join(", ");
+  throw new Error(`Validation failed: ${summary}`);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  z
+  parseSchema
 });

package/dist/schema/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Shared types for schema validation.
+ *
+ * `Schema<T>` is the Zod-shaped duck-type contract — any validator with
+ * a `.safeParse(data)` method returning `{ success, data?, error? }`
+ * satisfies it. socket-lib detects Zod (v3 and v4) structurally via this
+ * interface; consumers bring their own Zod.
+ *
+ * `ValidateResult<T>` / `ValidationIssue` / `Infer<S>` / `AnySchema` are
+ * the normalized shapes produced by `@socketsecurity/lib/schema/validate`
+ * and `@socketsecurity/lib/schema/parse`.
+ */
+/**
+ * Result of a Zod-shaped schema's `.safeParse()` call.
+ *
+ * @template T - The expected type of the parsed data
+ */
+export interface ParseResult<T> {
+    /** Indicates whether parsing was successful */
+    success: boolean;
+    /** Parsed and validated data (only present when `success` is `true`) */
+    data?: T | undefined;
+    /** Error information (only present when `success` is `false`) */
+    error?: unknown;
+}
+/**
+ * Zod-shaped duck-type for any validator exposing `safeParse` / `parse`.
+ *
+ * @template T - The expected output type after validation
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const userSchema = z.object({ name: z.string(), age: z.number() })
+ *
+ * // Schema satisfies this interface
+ * const schema: Schema<User> = userSchema
+ * const result = schema.safeParse({ name: 'Alice', age: 30 })
+ * ```
+ */
+export interface Schema<T = unknown> {
+    /** Non-throwing parse. */
+    safeParse(data: unknown): ParseResult<T>;
+    /** Throwing parse. */
+    parse(data: unknown): T;
+    /** Optional schema name for debugging. */
+    _name?: string | undefined;
+}
+/**
+ * Internal structural shape of a Zod v4 schema — carries the inferred
+ * output type on `_zod.output`. Used for type-only detection in `Infer<S>`.
+ *
+ * @internal
+ */
+interface ZodV4LikeSchema<O = unknown> {
+    _zod: {
+        output: O;
+    };
+    safeParse(data: unknown): unknown;
+}
+/**
+ * Internal structural shape of a Zod v3 schema — carries the inferred
+ * output type on `_output`. Used for type-only detection in `Infer<S>`.
+ *
+ * @internal
+ */
+interface ZodV3LikeSchema<O = unknown> {
+    _output: O;
+    safeParse(data: unknown): unknown;
+}
+/**
+ * Internal structural shape of a TypeBox `TSchema` — carries the inferred
+ * output type on the phantom `static` field. Only used inside socket-lib
+ * for type-only detection in `Infer<S>`; external callers should pass
+ * Zod schemas.
+ *
+ * @internal
+ */
+interface TypeBoxLikeSchema {
+    static: unknown;
+}
+/**
+ * Any schema kind the validators accept.
+ */
+export type AnySchema = ZodV4LikeSchema<unknown> | ZodV3LikeSchema<unknown> | TypeBoxLikeSchema | Schema<unknown>;
+/**
+ * Infer the validated output type from any supported schema kind.
+ *
+ * Order matters: TypeBox schemas carry a phantom `static` field, so we
+ * check for TypeBox before falling through to Zod and the duck-type.
+ */
+export type Infer<S> = S extends {
+    static: infer Static;
+} ? Static : S extends {
+    _zod: {
+        output: infer O;
+    };
+} ? O : S extends {
+    _output: infer O;
+} ? O : S extends Schema<infer T> ? T : unknown;
+/**
+ * A single normalized validation error.
+ */
+export interface ValidationIssue {
+    /** Array path into the value (e.g. `['user', 'age']`). */
+    path: Array<string | number>;
+    /** Human-readable description of the failure. */
+    message: string;
+}
+/**
+ * Tagged-union result of `validateSchema`. Callers narrow on `ok`.
+ */
+export type ValidateResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    errors: ValidationIssue[];
+};
+export {};

package/dist/schema/validate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Universal schema validator — non-throwing.
+ *
+ * Accepts any Zod-shaped schema (`.safeParse`-exposing) and returns a tagged
+ * result `{ ok: true, value } | { ok: false, errors }` with normalized
+ * `{ path, message }` issues. No runtime dependency on `zod` — detection
+ * is purely structural.
+ *
+ * @internal
+ * socket-lib additionally recognizes TypeBox schemas for its own internal
+ * use (e.g. `src/ipc.ts`'s stub-file validation). That path is not a
+ * supported consumer API.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod'
+ * import { validateSchema } from '@socketsecurity/lib/schema/validate'
+ *
+ * const User = z.object({ name: z.string() })
+ * const r = validateSchema(User, data)
+ * if (r.ok) r.value.name // string
+ * else r.errors           // ValidationIssue[]
+ * ```
+ */
+import type { Infer, ValidateResult } from './types';
+/**
+ * Validate `data` against a Zod-style `schema`. Non-throwing.
+ *
+ * The return type narrows `value` to `Infer<S>`, so callers get
+ * `z.infer<typeof S>` with no casts. Errors are normalized to
+ * `{ path, message }` regardless of the underlying validator.
+ *
+ * @throws {TypeError} When `schema` is not a recognized validator kind.
+ */
+export declare function validateSchema<S>(schema: S, data: unknown): ValidateResult<Infer<S>>;

package/dist/schema/validate.js

@@ -0,0 +1,98 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_exports = {};
+__export(validate_exports, {
+  validateSchema: () => validateSchema
+});
+module.exports = __toCommonJS(validate_exports);
+function isTypeBoxSchema(schema) {
+  if (schema === null || typeof schema !== "object") {
+    return false;
+  }
+  for (const sym of Object.getOwnPropertySymbols(schema)) {
+    if (sym.description === "TypeBox.Kind") {
+      return typeof schema[sym] === "string";
+    }
+  }
+  return false;
+}
+function normalizeTypeBoxErrors(errors) {
+  const out = [];
+  for (const err of errors) {
+    const segs = err.path.split("/").filter(Boolean);
+    out.push({
+      path: segs.map((s) => {
+        const n = Number(s);
+        return Number.isInteger(n) && String(n) === s ? n : s;
+      }),
+      message: err.message
+    });
+  }
+  return out;
+}
+function normalizeZodError(err) {
+  if (err === null || typeof err !== "object") {
+    return [{ path: [], message: String(err) }];
+  }
+  const issues = err.issues;
+  if (!Array.isArray(issues)) {
+    return [{ path: [], message: "Unknown validation error" }];
+  }
+  return issues.map((issue) => {
+    const i = issue;
+    return {
+      path: Array.isArray(i.path) ? i.path : [],
+      message: typeof i.message === "string" ? i.message : "Invalid value"
+    };
+  });
+}
+function validateSchema(schema, data) {
+  if (isTypeBoxSchema(schema)) {
+    const { Value } = require("../external/@sinclair/typebox/value");
+    if (Value.Check(schema, data)) {
+      return { ok: true, value: data };
+    }
+    return {
+      ok: false,
+      errors: normalizeTypeBoxErrors(Value.Errors(schema, data))
+    };
+  }
+  if (schema !== null && typeof schema === "object" && typeof schema.safeParse === "function") {
+    const result = schema.safeParse(data);
+    if (result.success === true) {
+      return {
+        ok: true,
+        value: result.data
+      };
+    }
+    return {
+      ok: false,
+      errors: normalizeZodError(result.error)
+    };
+  }
+  throw new TypeError(
+    "validateSchema: unsupported schema kind. Expected a Zod schema or an object with a safeParse method."
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateSchema
+});

package/dist/stdio/progress.js

@@ -174,7 +174,7 @@ class ProgressBar {
    * Format time in seconds to human readable.
    */
   formatTime(ms) {
-    const seconds = Math.round(ms / 1e3);
+    const seconds = Math.max(0, Math.round(ms / 1e3));
     if (seconds < 60) {
       return `${seconds}s`;
     }

package/dist/suppress-warnings.js

@@ -95,7 +95,6 @@ function suppressWarningType(warningType) {
 }
 async function withSuppressedWarnings(warningType, callback) {
   const wasAlreadySuppressed = suppressedWarnings.has(warningType);
-  const original = import_node_process.default.emitWarning;
   suppressWarningType(warningType);
   try {
     return await callback();
@@ -103,7 +102,6 @@ async function withSuppressedWarnings(warningType, callback) {
     if (!wasAlreadySuppressed) {
       suppressedWarnings.delete(warningType);
     }
-    import_node_process.default.emitWarning = original;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/tables.js

@@ -37,11 +37,10 @@ module.exports = __toCommonJS(tables_exports);
 var import_yoctocolors_cjs = __toESM(require("./external/yoctocolors-cjs"));
 var import_strings = require("./strings");
 function displayWidth(text) {
-  return (0, import_strings.stripAnsi)(text).length;
+  return (0, import_strings.stringWidth)(text);
 }
 function padText(text, width, align = "left") {
-  const stripped = (0, import_strings.stripAnsi)(text);
-  const textWidth = stripped.length;
+  const textWidth = displayWidth(text);
   const padding = Math.max(0, width - textWidth);
   switch (align) {
     case "right":

package/dist/url.js

@@ -73,7 +73,11 @@ function urlSearchParamAsBoolean(value, options) {
   };
   if (typeof value === "string") {
     const trimmed = value.trim();
-    return trimmed === "1" || trimmed.toLowerCase() === "true";
+    if (trimmed === "") {
+      return !!defaultValue;
+    }
+    const lowered = trimmed.toLowerCase();
+    return lowered === "1" || lowered === "true" || lowered === "yes" || lowered === "on";
   }
   if (value === null || value === void 0) {
     return !!defaultValue;

package/dist/versions.js

@@ -111,11 +111,11 @@ function isValidVersion(version) {
 }
 function maxVersion(versions) {
   const semver = getSemver();
-  return semver.maxSatisfying(versions, "*") || void 0;
+  return semver.maxSatisfying(versions, "*", { includePrerelease: true }) || void 0;
 }
 function minVersion(versions) {
   const semver = getSemver();
-  return semver.minSatisfying(versions, "*") || void 0;
+  return semver.minSatisfying(versions, "*", { includePrerelease: true }) || void 0;
 }
 function parseVersion(version) {
   const semver = getSemver();

package/dist/words.js

@@ -27,18 +27,15 @@ __export(words_exports, {
 module.exports = __toCommonJS(words_exports);
 // @__NO_SIDE_EFFECTS__
 function capitalize(word) {
-  const { length } = word;
-  if (length === 0) {
+  if (word.length === 0) {
     return word;
   }
-  if (length === 1) {
-    return word.toUpperCase();
-  }
-  return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`;
+  const [first, ...rest] = [...word];
+  return (first ?? "").toUpperCase() + rest.join("").toLowerCase();
 }
 // @__NO_SIDE_EFFECTS__
 function determineArticle(word) {
-  return /^[aeiou]/.test(word) ? "an" : "a";
+  return /^[aeiou]/i.test(word) ? "an" : "a";
 }
 // @__NO_SIDE_EFFECTS__
 function pluralize(word, options) {