@bgord/tools 0.15.1 → 0.16.0

package/dist/weight.vo.d.ts

@@ -3,6 +3,18 @@ export declare enum WeightUnit {
     kg = "kg",
     lb = "lb"
 }
+export declare const WeightNonFiniteError: {
+    readonly error: "weight.non_finite";
+};
+export declare const WeightNegativeError: {
+    readonly error: "weight.negative";
+};
+export declare const WeightNonPositiveError: {
+    readonly error: "weight.non_positive";
+};
+export declare const WeightGramsNonNegativeError: {
+    readonly error: "weight.grams_non_negative";
+};
 export declare class Weight {
     private readonly grams;
     private static readonly GRAMS_PER_KILOGRAM;

package/dist/weight.vo.js

@@ -1,16 +1,26 @@
 import { z } from "zod/v4";
 import { RoundToDecimal } from "./rounding.adapter";
-const FiniteNumericValue = z.number().refine(Number.isFinite, { message: "Expected a finite number" });
-const NonNegativeNumericValue = FiniteNumericValue.min(0, { message: "Must be greater than or equal to 0" });
-const PositiveNumericValue = FiniteNumericValue.gt(0, { message: "Must be greater than 0" });
-const NonNegativeIntegerGrams = FiniteNumericValue.int().min(0, {
-    message: "Grams must be an integer greater than or equal to 0",
-});
 export var WeightUnit;
 (function (WeightUnit) {
     WeightUnit["kg"] = "kg";
     WeightUnit["lb"] = "lb";
 })(WeightUnit || (WeightUnit = {}));
+export const WeightNonFiniteError = { error: "weight.non_finite" };
+export const WeightNegativeError = { error: "weight.negative" };
+export const WeightNonPositiveError = { error: "weight.non_positive" };
+export const WeightGramsNonNegativeError = { error: "weight.grams_non_negative" };
+const WeightQuantityNumber = z
+    .number(WeightNonFiniteError)
+    .refine(Number.isFinite, WeightNonFiniteError)
+    .min(0, WeightNegativeError);
+const DivisionScalarNumber = z
+    .number(WeightNonFiniteError)
+    .refine(Number.isFinite, WeightNonFiniteError)
+    .gt(0, WeightNonPositiveError);
+const CanonicalGramsInteger = z
+    .number(WeightGramsNonNegativeError)
+    .int(WeightGramsNonNegativeError)
+    .min(0, WeightGramsNonNegativeError);
 export class Weight {
     grams;
     static GRAMS_PER_KILOGRAM = 1_000;
@@ -20,22 +30,22 @@ export class Weight {
         this.grams = grams;
     }
     static fromKilograms(kilograms) {
-        NonNegativeNumericValue.parse(kilograms);
-        const gramsRounded = Math.round(kilograms * Weight.GRAMS_PER_KILOGRAM);
-        NonNegativeIntegerGrams.parse(gramsRounded);
-        return new Weight(gramsRounded);
+        const kilogramsParsed = WeightQuantityNumber.parse(kilograms);
+        const gramsRounded = Math.round(kilogramsParsed * Weight.GRAMS_PER_KILOGRAM);
+        const grams = CanonicalGramsInteger.parse(gramsRounded);
+        return new Weight(grams);
     }
     static fromPounds(pounds) {
-        NonNegativeNumericValue.parse(pounds);
-        const gramsRounded = Math.round(pounds * Weight.KILOGRAMS_PER_POUND * Weight.GRAMS_PER_KILOGRAM);
-        NonNegativeIntegerGrams.parse(gramsRounded);
-        return new Weight(gramsRounded);
+        const poundsParsed = WeightQuantityNumber.parse(pounds);
+        const gramsRounded = Math.round(poundsParsed * Weight.KILOGRAMS_PER_POUND * Weight.GRAMS_PER_KILOGRAM);
+        const grams = CanonicalGramsInteger.parse(gramsRounded);
+        return new Weight(grams);
     }
     static fromGrams(grams) {
-        NonNegativeNumericValue.parse(grams);
-        const gramsRounded = Math.round(grams);
-        NonNegativeIntegerGrams.parse(gramsRounded);
-        return new Weight(gramsRounded);
+        const gramsParsed = WeightQuantityNumber.parse(grams);
+        const gramsRounded = Math.round(gramsParsed);
+        const integerGrams = CanonicalGramsInteger.parse(gramsRounded);
+        return new Weight(integerGrams);
     }
     static zero() {
         return new Weight(0);
@@ -52,7 +62,7 @@ export class Weight {
         return rounding ? rounding.round(pounds) : pounds;
     }
     format(unit, rounding = new RoundToDecimal(2)) {
-        const value = { [WeightUnit.kg]: this.toKilograms(rounding), [WeightUnit.lb]: this.toPounds(rounding) }[unit];
+        const value = unit === WeightUnit.kg ? this.toKilograms(rounding) : this.toPounds(rounding);
         return `${value.toString()} ${unit}`;
     }
     add(other) {
@@ -63,16 +73,16 @@ export class Weight {
         return new Weight(result < 0 ? 0 : result);
     }
     multiply(factor) {
-        NonNegativeNumericValue.parse(factor);
-        const gramsRounded = Math.round(this.grams * factor);
-        NonNegativeIntegerGrams.parse(gramsRounded);
-        return new Weight(gramsRounded);
+        const factorParsed = WeightQuantityNumber.parse(factor);
+        const gramsRounded = Math.round(this.grams * factorParsed);
+        const grams = CanonicalGramsInteger.parse(gramsRounded);
+        return new Weight(grams);
     }
     divideByScalar(divisor) {
-        PositiveNumericValue.parse(divisor);
-        const gramsRounded = Math.round(this.grams / divisor);
-        NonNegativeIntegerGrams.parse(gramsRounded);
-        return new Weight(gramsRounded);
+        const divisorParsed = DivisionScalarNumber.parse(divisor);
+        const gramsRounded = Math.round(this.grams / divisorParsed);
+        const grams = CanonicalGramsInteger.parse(gramsRounded);
+        return new Weight(grams);
     }
     equals(other) {
         return this.grams === other.grams;

package/dist/year-iso-id.vo.d.ts

@@ -1,3 +1,6 @@
 import { z } from "zod/v4";
+export declare const YearIsoIdError: {
+    readonly error: "year-iso-id.invalid";
+};
 export declare const YearIsoId: z.ZodString;
 export type YearIsoIdType = z.infer<typeof YearIsoId>;

package/dist/year-iso-id.vo.js

@@ -1,8 +1,6 @@
 import { z } from "zod/v4";
+export const YearIsoIdError = { error: "year-iso-id.invalid" };
 export const YearIsoId = z
-    .string()
-    .regex(/^\d{4}$/)
-    .refine((value) => {
-    const year = Number(value);
-    return value.length === 4 && Number.isInteger(year);
-}, { message: "year-iso-id.invalid" });
+    .string(YearIsoIdError)
+    .regex(/^\d{4}$/, YearIsoIdError)
+    .refine((value) => Number.isInteger(Number(value)), YearIsoIdError);

package/dist/year.vo.d.ts

@@ -1,6 +1,8 @@
 import { DateRange } from "./date-range.vo";
 import { type TimestampType } from "./timestamp.vo";
 import { type YearIsoIdType } from "./year-iso-id.vo";
+export declare const YearInvalidIntegerError: "year.invalid_integer";
+export declare const YearOutOfRangeError: "year.out_of_range";
 export declare class Year extends DateRange {
     toIsoId(): YearIsoIdType;
     isLeapYear(): boolean;

package/dist/year.vo.js

@@ -2,6 +2,8 @@ import { addYears, endOfYear, getYear, startOfYear } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { Timestamp } from "./timestamp.vo";
 import { YearIsoId } from "./year-iso-id.vo";
+export const YearInvalidIntegerError = "year.invalid_integer";
+export const YearOutOfRangeError = "year.out_of_range";
 export class Year extends DateRange {
     toIsoId() {
         return String(getYear(this.getStart()));
@@ -32,9 +34,9 @@ export class Year extends DateRange {
     }
     static fromNumber(value) {
         if (!Number.isInteger(value))
-            throw new Error("year.invalid_integer");
+            throw new Error(YearInvalidIntegerError);
         if (value < 0 || value > 9999)
-            throw new Error("year.out_of_range");
+            throw new Error(YearOutOfRangeError);
         const reference = Timestamp.parse(Date.UTC(value, 0, 1, 0, 0, 0, 0));
         return Year.fromTimestamp(reference);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",

package/readme.md

@@ -81,7 +81,6 @@ src/
 ├── rounding.port.ts
 ├── simple-linear-regression.service.ts
 ├── size.vo.ts
-├── stepper.service.ts
 ├── stopwatch.service.ts
 ├── streak-calculator.service.ts
 ├── sum.service.ts

package/src/basename.vo.ts

@@ -1,18 +1,29 @@
 import { z } from "zod/v4";
 
-export const BasenameSchema = z
-  .string()
+export const BasenameTypeError = "basename.not.string" as const;
+export const BasenameEmptyError = "basename.empty" as const;
+export const BasenameTooLongError = "basename.too.long" as const;
+export const BasenameSlashesForbiddenError = "basename.slashes.forbidden" as const;
+export const BasenameControlCharsForbiddenError = "basename.control.chars.forbidden" as const;
+export const BasenameDotSegmentsForbiddenError = "basename.dot.segments.forbidden" as const;
+export const BasenameDotfilesForbiddenError = "basename.dotfiles.forbidden" as const;
+export const BasenameTrailingDotForbiddenError = "basename.trailing.dot.forbidden" as const;
+export const BasenameBadCharsError = "basename.bad.chars" as const;
+
+export const Basename = z
+  .string(BasenameTypeError)
   .trim()
-  .min(1, "basename_empty")
-  .max(128, "basename_too_long")
-  .refine((s) => !/[/\\]/.test(s), "basename_slashes_forbidden")
+  .min(1, BasenameEmptyError)
+  .max(128, BasenameTooLongError)
+  .refine((s) => !/[/\\]/.test(s), BasenameSlashesForbiddenError)
+  // dot-related checks: dot-segments first for specific errors…
   // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-  .refine((s) => !/[\u0000-\u001F\u007F]/.test(s), "basename_control_chars_forbidden")
-  // check dot-segments FIRST so "." / ".." get the intended error
-  .refine((s) => s !== "." && s !== "..", "basename_dot_segments_forbidden")
-  // then disallow any other dotfile (".env", ".gitignore", etc.)
-  .refine((s) => !s.startsWith("."), "basename_dotfiles_forbidden")
-  .refine((s) => !s.endsWith("."), "basename_trailing_dot_forbidden")
-  .regex(/^[A-Za-z0-9._-]+$/, "basename_bad_chars")
-  .brand("basename");
-export type BasenameType = z.infer<typeof BasenameSchema>;
+  .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), BasenameControlCharsForbiddenError)
+  .refine((value) => value !== "." && value !== "..", BasenameDotSegmentsForbiddenError)
+  // …then any other dotfile
+  .refine((value) => !value.startsWith("."), BasenameDotfilesForbiddenError)
+  .refine((value) => !value.endsWith("."), BasenameTrailingDotForbiddenError)
+  .regex(/^[A-Za-z0-9._-]+$/, BasenameBadCharsError)
+  .brand("Basename");
+
+export type BasenameType = z.infer<typeof Basename>;

package/src/clock.vo.ts

@@ -17,6 +17,7 @@ export class Clock {
   static fromEpochMs(timestamp: TimestampType, formatter?: ClockFormatter): Clock {
     const hour = Hour.fromEpochMs(timestamp);
     const minute = Minute.fromEpochMs(timestamp);
+
     return new Clock(hour, minute, formatter);
   }
 

package/src/date-calculator.service.ts

@@ -1,26 +1,21 @@
 import { Time } from "./time.service";
-import type { TimestampType } from "./timestamp.vo";
+import { Timestamp, type TimestampType } from "./timestamp.vo";
 
 type GetStartOfDayTsInTzConfigType = { now: TimestampType; timeZoneOffsetMs: number };
 
 export class DateCalculator {
-  static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType) {
-    const startOfDayUTC = new Date();
-    startOfDayUTC.setUTCHours(0, 0, 0, 0);
+  static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): TimestampType {
+    const dayMs = Time.Days(1).ms;
 
-    const startOfDayInTimeZone = startOfDayUTC.getTime() + config.timeZoneOffsetMs;
+    // UTC midnight for the UTC date of `now`
+    const utcMidnight = Math.floor(config.now / dayMs) * dayMs;
 
-    const timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay =
-      (config.now - startOfDayInTimeZone) % Time.Days(1).ms;
+    // Candidate start of the local day (in UTC), anchored to the same UTC date
+    let start = utcMidnight + config.timeZoneOffsetMs;
 
-    if (timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay >= Time.Days(1).ms) {
-      return config.now - timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay + Time.Days(1).ms;
-    }
+    // If the candidate is in the future relative to `now`, it means local midnight was "yesterday" in UTC.
+    if (start > config.now) start -= dayMs;
 
-    if (timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay >= 0) {
-      return config.now - timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay;
-    }
-
-    return config.now - timeSinceNewDayInTimeZoneRelativeToUtcStartOfDay - Time.Days(1).ms;
+    return Timestamp.parse(start);
   }
 }

package/src/date-range.vo.ts

@@ -1,11 +1,13 @@
 import type { TimestampType } from "./timestamp.vo";
 
+export const DateRangeInvalidError = "invalid.date.range" as const;
+
 export class DateRange {
   constructor(
     private readonly start: TimestampType,
     private readonly end: TimestampType,
   ) {
-    if (start > end) throw new Error("Invalid date range");
+    if (start > end) throw new Error(DateRangeInvalidError);
   }
 
   getStart(): TimestampType {

package/src/day-iso-id.vo.ts

@@ -1,16 +1,15 @@
 import { isValid, parseISO } from "date-fns";
 import { z } from "zod/v4";
 
+export const DayIsoIdError = { error: "invalid.day.iso.id" } as const;
+
 export const DayIsoId = z
-  .string()
-  // 4-digit year, 2-digit month, 2-digit day
-  .regex(/^\d{4}-\d{2}-\d{2}$/)
-  .refine(
-    (value) => {
-      const date = parseISO(value);
-      return isValid(date) && value === date.toISOString().slice(0, 10);
-    },
-    { message: "day-iso-id.invalid" },
-  );
+  .string(DayIsoIdError)
+  .regex(/^\d{4}-\d{2}-\d{2}$/, DayIsoIdError)
+  .refine((value) => {
+    const date = parseISO(value);
+
+    return isValid(date) && value === date.toISOString().slice(0, 10);
+  }, DayIsoIdError);
 
 export type DayIsoIdType = z.infer<typeof DayIsoId>;

package/src/day.vo.ts

@@ -1,4 +1,3 @@
-import { addDays, endOfDay, startOfDay } from "date-fns";
 import { DateRange } from "./date-range.vo";
 import { DayIsoId, type DayIsoIdType } from "./day-iso-id.vo";
 import { Time } from "./time.service";
@@ -10,28 +9,35 @@ export class Day extends DateRange {
   }
 
   toIsoId(): DayIsoIdType {
-    return new Date(this.getStart() + Time.Hours(12).ms).toISOString().slice(0, 10) as DayIsoIdType;
+    const midday = this.getStart() + Time.Hours(12).ms;
+
+    return new Date(midday).toISOString().slice(0, 10) as DayIsoIdType;
   }
 
   previous(): Day {
-    const shifted = addDays(new Date(this.getStart()), -1).getTime();
+    const shifted = this.getStart() - Time.Days(1).ms;
+
     return Day.fromTimestamp(Timestamp.parse(shifted));
   }
 
   next(): Day {
-    const shifted = addDays(new Date(this.getStart()), 1).getTime();
+    const shifted = this.getStart() + Time.Days(1).ms;
+
     return Day.fromTimestamp(Timestamp.parse(shifted));
   }
 
   shift(count: number): Day {
-    const shifted = addDays(new Date(this.getStart()), count).getTime();
+    const shifted = this.getStart() + count * Time.Days(1).ms;
+
     return Day.fromTimestamp(Timestamp.parse(shifted));
   }
 
   static fromTimestamp(timestamp: TimestampType): Day {
-    const start = Timestamp.parse(startOfDay(timestamp).getTime());
-    const end = Timestamp.parse(endOfDay(timestamp).getTime());
-    return new Day(start, end);
+    const date = new Date(timestamp);
+    const startUtc = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+    const endUtc = startUtc + Time.Days(1).ms - 1;
+
+    return new Day(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
   }
 
   static fromNow(now: TimestampType): Day {
@@ -40,8 +46,9 @@ export class Day extends DateRange {
 
   static fromIsoId(isoId: DayIsoIdType): Day {
     const [year, month, day] = DayIsoId.parse(isoId).split("-").map(Number);
+    const startUtc = Date.UTC(year, month - 1, day);
+    const endUtc = startUtc + Time.Days(1).ms - 1;
 
-    const reference = new Date(Date.UTC(year, month - 1, day));
-    return Day.fromTimestamp(Timestamp.parse(reference.getTime()));
+    return new Day(Timestamp.parse(startUtc), Timestamp.parse(endUtc));
   }
 }

package/src/directory-path-absolute.vo.ts

@@ -1,12 +1,19 @@
 import { z } from "zod/v4";
 
+export const AbsDirTypeError = "abs_dir.not.string" as const;
+export const AbsDirMustStartWithSlashError = "abs_dir_must_start_with_slash" as const;
+export const AbsDirBackslashForbiddenError = "abs_dir_backslash_forbidden" as const;
+export const AbsDirControlCharsForbiddenError = "abs_dir_control_chars_forbidden" as const;
+export const AbsDirBadSegmentsError = "abs_dir_bad_segments" as const;
+
 export const DirectoryPathAbsoluteSchema = z
-  .string()
+  .string(AbsDirTypeError)
   .trim()
-  .refine((value) => value.startsWith("/"), "abs_dir_must_start_with_slash")
-  .refine((value) => !value.includes("\\"), "abs_dir_backslash_forbidden")
+  .refine((value) => value.startsWith("/"), AbsDirMustStartWithSlashError)
+  .refine((value) => !value.includes("\\"), AbsDirBackslashForbiddenError)
   // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-  .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), "abs_dir_control_chars_forbidden")
+  .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), AbsDirControlCharsForbiddenError)
+  // collapse duplicate slashes, then drop trailing slash unless it's the root "/"
   .transform((value) => value.replace(/\/{2,}/g, "/"))
   .transform((value) => (value !== "/" && value.endsWith("/") ? value.slice(0, -1) : value))
   .refine((value) => {
@@ -16,7 +23,7 @@ export const DirectoryPathAbsoluteSchema = z
       (segment) =>
         segment.length > 0 && /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== "..",
     );
-  }, "abs_dir_bad_segments")
+  }, AbsDirBadSegmentsError)
   .brand("directory_path_absolute");
 
 export type DirectoryPathAbsoluteType = z.infer<typeof DirectoryPathAbsoluteSchema>;

package/src/directory-path-relative.vo.ts

@@ -1,21 +1,28 @@
 import { z } from "zod/v4";
 
+export const RelDirTypeError = "rel_dir.not.string" as const;
+export const RelDirMustNotStartWithSlashError = "rel_dir_must_not_start_with_slash" as const;
+export const RelDirBackslashForbiddenError = "rel_dir_backslash_forbidden" as const;
+export const RelDirControlCharsForbiddenError = "rel_dir_control_chars_forbidden" as const;
+export const RelDirEmptyError = "rel_dir_empty" as const;
+export const RelDirBadSegmentsError = "rel_dir_bad_segments" as const;
+
 export const DirectoryPathRelativeSchema = z
-  .string()
+  .string(RelDirTypeError)
   .trim()
-  .refine((value) => !value.startsWith("/"), "rel_dir_must_not_start_with_slash")
-  .refine((value) => !value.includes("\\"), "rel_dir_backslash_forbidden")
+  .refine((value) => !value.startsWith("/"), RelDirMustNotStartWithSlashError)
+  .refine((value) => !value.includes("\\"), RelDirBackslashForbiddenError)
   // biome-ignore lint: lint/suspicious/noControlCharactersInRegex
-  .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), "rel_dir_control_chars_forbidden")
+  .refine((value) => !/[\u0000-\u001F\u007F]/.test(value), RelDirControlCharsForbiddenError)
   .transform((value) => value.replace(/\/{2,}/g, "/"))
   .transform((value) => value.replace(/^\/+|\/+$/g, ""))
-  .refine((value) => value.length > 0, "rel_dir_empty")
+  .refine((value) => value.length > 0, RelDirEmptyError)
   .refine(
     (value) =>
       value
         .split("/")
         .every((segment) => /^[A-Za-z0-9._-]+$/.test(segment) && segment !== "." && segment !== ".."),
-    "rel_dir_bad_segments",
+    RelDirBadSegmentsError,
   )
   .brand("directory_path_relative");
 

package/src/dll.service.ts

@@ -9,13 +9,11 @@ export class Node<T> {
 
   forward(n: number): Node<T> | null {
     let currentNode: Node<T> | null = this;
+    let steps = n;
 
-    for (let i = 0; i < n; i++) {
-      if (currentNode === null) {
-        return currentNode;
-      }
-
+    while (steps > 0 && currentNode) {
       currentNode = currentNode.next;
+      steps -= 1;
     }
 
     return currentNode;
@@ -23,14 +21,13 @@ export class Node<T> {
 
   backward(n: number): Node<T> | null {
     let currentNode: Node<T> | null = this;
+    let steps = n;
 
-    for (let i = 0; i < n; i++) {
-      if (currentNode === null) {
-        return currentNode;
-      }
-
+    while (steps > 0 && currentNode) {
       currentNode = currentNode.prev;
+      steps -= 1;
     }
+
     return currentNode;
   }
 }
@@ -58,39 +55,31 @@ export class DoublyLinkedList<T> {
   }
 
   append(node: Node<T>): void {
-    if (this.head === null || this.tail === null) {
-      this.size++;
-
+    if (this.tail === null) {
       this.head = node;
       this.tail = node;
     } else {
-      this.size++;
-
       this.tail.next = node;
       node.prev = this.tail;
-
       this.tail = node;
     }
+    this.size += 1;
   }
 
   prepend(node: Node<T>): void {
-    if (this.head === null || this.tail === null) {
-      this.size++;
-
+    if (this.head === null) {
       this.head = node;
       this.tail = node;
     } else {
-      this.size++;
-
       node.next = this.head;
       this.head.prev = node;
       this.head = node;
     }
+    this.size += 1;
   }
 
   clear(): void {
     this.size = 0;
-
     this.head = null;
     this.tail = null;
   }
@@ -108,7 +97,7 @@ export class DoublyLinkedList<T> {
       this.tail = node.prev;
     }
 
-    this.size--;
+    this.size -= 1;
     node.prev = null;
     node.next = null;
   }
@@ -116,40 +105,57 @@ export class DoublyLinkedList<T> {
   insertAfter(node: Node<T>, target: Node<T>): void {
     if (target === this.tail) {
       this.append(node);
-    } else {
-      this.size++;
+      return;
+    }
+
+    const nextNode = target.next;
+    this.size += 1;
+
+    node.prev = target;
+    node.next = nextNode;
 
-      node.prev = target;
-      node.next = target.next;
-      // biome-ignore lint: lint/style/noNonNullAssertion
-      target.next!.prev = node;
-      target.next = node;
+    if (nextNode) {
+      nextNode.prev = node;
     }
+
+    target.next = node;
   }
 
   insertBefore(node: Node<T>, target: Node<T>): void {
     if (target === this.head) {
       this.prepend(node);
-    } else {
-      this.size++;
+      return;
+    }
+
+    const prevNode = target.prev;
+    this.size += 1;
 
-      node.next = target;
-      node.prev = target.prev;
-      // biome-ignore lint: lint/style/noNonNullAssertion
-      target.prev!.next = node;
-      target.prev = node;
+    node.next = target;
+    node.prev = prevNode;
+
+    if (prevNode) {
+      prevNode.next = node;
     }
+
+    target.prev = node;
   }
 
   find(callback: (node: Node<T>) => boolean): Node<T> | null {
-    return Array.from(this).find(callback) ?? null;
+    let current = this.head;
+    while (current) {
+      if (callback(current)) return current;
+      current = current.next;
+    }
+    return null;
   }
 
   reverse(): void {
     [this.head, this.tail] = [this.tail, this.head];
 
     for (const node of this) {
-      [node.prev, node.next] = [node.next, node.prev];
+      const originalNext = node.next;
+      node.next = node.prev;
+      node.prev = originalNext;
     }
   }
 
@@ -159,20 +165,16 @@ export class DoublyLinkedList<T> {
 
   static fromArray<T>(array: T[]): DoublyLinkedList<T> {
     const dll = new DoublyLinkedList<T>();
-
     for (const item of array) {
       dll.append(new Node<T>(item));
     }
-
     return dll;
   }
 
   *[Symbol.iterator](): IterableIterator<Node<T>> {
     let current: Node<T> | null = this.head;
-
     while (current) {
       yield current;
-
       current = current.next;
     }
   }