@bgord/tools 1.4.5 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",
@@ -26,12 +26,12 @@
     "@stryker-mutator/core": "9.6.0",
     "@types/bun": "1.3.11",
     "cspell": "9.7.0",
-    "knip": "6.0.2",
+    "knip": "6.0.4",
     "lefthook": "2.1.4",
     "lockfile-lint": "5.0.0",
     "only-allow": "1.2.2",
     "shellcheck": "4.1.0",
-    "typescript": "5.9.3"
+    "typescript": "6.0.2"
   },
   "dependencies": {
     "date-fns": "4.1.0",

package/dist/age-years.vo.d.ts

@@ -1,11 +0,0 @@
-import * as v from "valibot";
-export declare const AgeYearsError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const AgeYearsConstraints: {
-    min: number;
-    max: number;
-};
-export declare const AgeYears: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.MaxValueAction<number, 130, string>, v.BrandAction<number, "AgeYears">]>;
-export type AgeYearsType = v.InferOutput<typeof AgeYears>;

package/dist/age-years.vo.js

@@ -1,6 +0,0 @@
-import * as v from "valibot";
-export const AgeYearsError = { Type: "age.years.type", Invalid: "age.years.invalid" };
-export const AgeYearsConstraints = { min: 0, max: 130 };
-export const AgeYears = v.pipe(v.number(AgeYearsError.Type), v.integer(AgeYearsError.Type), v.minValue(0, AgeYearsError.Invalid), v.maxValue(130, AgeYearsError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("AgeYears"));

package/dist/age.vo.d.ts

@@ -1,28 +0,0 @@
-import { type AgeYearsType } from "./age-years.vo";
-import { Timestamp } from "./timestamp.vo";
-export declare const AgeError: {
-    FutureBirthdate: string;
-};
-export declare class Age {
-    private readonly value;
-    static readonly MIN: number;
-    static readonly MAX: number;
-    private constructor();
-    static fromValue(candidate: number): Age;
-    static fromValueSafe(candidate: AgeYearsType): Age;
-    static fromBirthdateTimestamp(params: {
-        birthdate: Timestamp;
-        now: Timestamp;
-    }): Age;
-    static fromBirthdate(candidate: {
-        birthdate: string;
-        now: Timestamp;
-    }): Age;
-    get(): AgeYearsType;
-    equals(other: Age): boolean;
-    isOlderThan(other: Age): boolean;
-    isYoungerThan(other: Age): boolean;
-    isAdult(minimumAge: Age): boolean;
-    toString(): string;
-    toJSON(): number;
-}

package/dist/age.vo.js

@@ -1,51 +0,0 @@
-import { differenceInYears } from "date-fns";
-import * as v from "valibot";
-import { AgeYears, AgeYearsConstraints } from "./age-years.vo";
-import { Timestamp } from "./timestamp.vo";
-export const AgeError = { FutureBirthdate: "age.future.birthdate" };
-export class Age {
-    value;
-    static MIN = AgeYearsConstraints.min;
-    static MAX = AgeYearsConstraints.max;
-    constructor(value) {
-        this.value = value;
-    }
-    static fromValue(candidate) {
-        return new Age(v.parse(AgeYears, candidate));
-    }
-    static fromValueSafe(candidate) {
-        return new Age(candidate);
-    }
-    static fromBirthdateTimestamp(params) {
-        if (params.birthdate.isAfter(params.now))
-            throw new Error(AgeError.FutureBirthdate);
-        return Age.fromValue(differenceInYears(params.now.ms, params.birthdate.ms));
-    }
-    static fromBirthdate(candidate) {
-        const birthdate = Timestamp.fromDateLike(candidate.birthdate);
-        if (birthdate.isAfter(candidate.now))
-            throw new Error(AgeError.FutureBirthdate);
-        return Age.fromValue(differenceInYears(candidate.now.ms, birthdate.ms));
-    }
-    get() {
-        return this.value;
-    }
-    equals(other) {
-        return this.value === other.value;
-    }
-    isOlderThan(other) {
-        return this.value > other.value;
-    }
-    isYoungerThan(other) {
-        return this.value < other.value;
-    }
-    isAdult(minimumAge) {
-        return this.value >= minimumAge.value;
-    }
-    toString() {
-        return this.get().toString();
-    }
-    toJSON() {
-        return this.get();
-    }
-}

package/dist/api-key.vo.d.ts

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export declare const ApiKeyError: {
-    Type: string;
-    BadChars: string;
-};
-export declare const ApiKey: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.BrandAction<string, "ApiKey">]>;
-export type ApiKeyType = v.InferOutput<typeof ApiKey>;

package/dist/api-key.vo.js

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export const ApiKeyError = { Type: "api.key.type", BadChars: "api.key.bad.chars" };
-// 64 letters and digits allowed
-const API_KEY_CHARS = /^[a-zA-Z0-9]{64}$/;
-export const ApiKey = v.pipe(v.string(ApiKeyError.Type), v.regex(API_KEY_CHARS, ApiKeyError.BadChars), 
-// Stryker disable next-line StringLiteral
-v.brand("ApiKey"));

package/dist/basename.vo.d.ts

@@ -1,12 +0,0 @@
-import * as v from "valibot";
-export declare const BasenameError: {
-    Type: string;
-    Empty: string;
-    TooLong: string;
-    DotSegments: string;
-    Dotfiles: string;
-    TrailingDot: string;
-    BadChars: string;
-};
-export declare const Basename: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 128, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.RegexAction<string, string>, v.BrandAction<string, "Basename">]>;
-export type BasenameType = v.InferOutput<typeof Basename>;

package/dist/basename.vo.js

@@ -1,22 +0,0 @@
-import * as v from "valibot";
-export const BasenameError = {
-    Type: "basename.type",
-    Empty: "basename.empty",
-    TooLong: "basename.too.long",
-    DotSegments: "basename.dot.segments",
-    Dotfiles: "basename.dotfiles",
-    TrailingDot: "basename.trailing.dot",
-    BadChars: "basename.bad.chars",
-};
-// Letters, digits, dots, underscores, and hyphens allowed
-const BASENAME_CHARS = /^[a-zA-Z0-9._-]+$/;
-const DOT_SEGMENTS = [".", ".."];
-export const Basename = v.pipe(v.string(BasenameError.Type), v.minLength(1, BasenameError.Empty), v.maxLength(128, BasenameError.TooLong), 
-// Reject "." and ".." as a filename to avoid directory traversal
-v.check((value) => !DOT_SEGMENTS.includes(value), BasenameError.DotSegments), 
-// Reject dotfiles like ".env"
-v.check((value) => !value.startsWith("."), BasenameError.Dotfiles), 
-// Reject trailing dot like "picture." to avoid extension collision
-v.check((value) => !value.endsWith("."), BasenameError.TrailingDot), v.regex(BASENAME_CHARS, BasenameError.BadChars), 
-// Stryker disable next-line StringLiteral
-v.brand("Basename"));

package/dist/batch.d.ts

@@ -1,2 +0,0 @@
-import type { IntegerPositiveType } from "./integer-positive.vo";
-export declare function batch<T>(array: Array<T>, size: IntegerPositiveType): Array<Array<T>>;

package/dist/batch.js

@@ -1,3 +0,0 @@
-export function batch(array, size) {
-    return Array.from({ length: Math.ceil(array.length / size) }, (_, index) => array.slice(index * size, (index + 1) * size));
-}

package/dist/date-calculator.service.d.ts

@@ -1,10 +0,0 @@
-import { Duration } from "./duration.service";
-import { Timestamp } from "./timestamp.vo";
-type GetStartOfDayTsInTzConfigType = {
-    now: Timestamp;
-    timeZoneOffset: Duration;
-};
-export declare class DateCalculator {
-    static getStartOfDayTsInTz(config: GetStartOfDayTsInTzConfigType): Timestamp;
-}
-export {};

package/dist/date-calculator.service.js

@@ -1,12 +0,0 @@
-import { Duration } from "./duration.service";
-import { Timestamp } from "./timestamp.vo";
-export class DateCalculator {
-    static getStartOfDayTsInTz(config) {
-        const dayMs = Duration.Days(1).ms;
-        const utcMidnightOfNow = Timestamp.fromNumber(Math.floor(config.now.ms / dayMs) * dayMs);
-        let startOfDayInTz = utcMidnightOfNow.add(config.timeZoneOffset);
-        if (startOfDayInTz.isAfter(config.now))
-            startOfDayInTz = startOfDayInTz.subtract(Duration.Days(1));
-        return startOfDayInTz;
-    }
-}

package/dist/date-formatter.service.d.ts

@@ -1,9 +0,0 @@
-import { format } from "date-fns";
-type DateFormattersInputType = Parameters<typeof format>[0];
-export declare class DateFormatters {
-    static datetime(date: DateFormattersInputType): string;
-    static date(date: DateFormattersInputType): string;
-    static monthDay(date: DateFormattersInputType): string;
-    static relative(date: DateFormattersInputType): string;
-}
-export {};

package/dist/date-formatter.service.js

@@ -1,15 +0,0 @@
-import { format, formatDistanceToNow } from "date-fns";
-export class DateFormatters {
-    static datetime(date) {
-        return format(date, "yyyy/MM/dd HH:mm");
-    }
-    static date(date) {
-        return format(date, "yyyy/MM/dd");
-    }
-    static monthDay(date) {
-        return format(date, "MM/dd");
-    }
-    static relative(date) {
-        return formatDistanceToNow(date, { addSuffix: true });
-    }
-}

package/dist/date-range.vo.d.ts

@@ -1,21 +0,0 @@
-import type { Duration } from "./duration.service";
-import type { Timestamp } from "./timestamp.vo";
-export declare const DateRangeError: {
-    Invalid: string;
-};
-export declare class DateRange {
-    private readonly start;
-    private readonly end;
-    constructor(start: Timestamp, end: Timestamp);
-    getStart(): Timestamp;
-    getEnd(): Timestamp;
-    get(): [Timestamp, Timestamp];
-    getDuration(): Duration;
-    contains(timestamp: Timestamp): boolean;
-    equals(other: DateRange): boolean;
-    toString(): string;
-    toJSON(): {
-        start: number;
-        end: number;
-    };
-}

package/dist/date-range.vo.js

@@ -1,35 +0,0 @@
-export const DateRangeError = { Invalid: "date.range.invalid" };
-export class DateRange {
-    start;
-    end;
-    constructor(start, end) {
-        this.start = start;
-        this.end = end;
-        if (start.isAfterOrEqual(end))
-            throw new Error(DateRangeError.Invalid);
-    }
-    getStart() {
-        return this.start;
-    }
-    getEnd() {
-        return this.end;
-    }
-    get() {
-        return [this.start, this.end];
-    }
-    getDuration() {
-        return this.end.difference(this.start);
-    }
-    contains(timestamp) {
-        return timestamp.isAfterOrEqual(this.start) && timestamp.isBeforeOrEqual(this.end);
-    }
-    equals(other) {
-        return this.start.equals(other.start) && this.end.equals(other.end);
-    }
-    toString() {
-        return `${this.start.toString()} - ${this.end.toString()}`;
-    }
-    toJSON() {
-        return { start: this.getStart().ms, end: this.getEnd().ms };
-    }
-}

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

@@ -1,9 +0,0 @@
-import * as v from "valibot";
-export declare const DayIsoIdError: {
-    Type: string;
-    BadChars: string;
-    InvalidDate: string;
-};
-export declare const DAY_ISO_ID_CHARS: RegExp;
-export declare const DayIsoId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.RegexAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "DayIsoId">]>;
-export type DayIsoIdType = v.InferOutput<typeof DayIsoId>;

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

@@ -1,12 +0,0 @@
-import { isValid, parseISO } from "date-fns";
-import * as v from "valibot";
-export const DayIsoIdError = {
-    Type: "day.iso.id.type",
-    BadChars: "day.iso.id.bad.chars",
-    InvalidDate: "day.iso.id.invalid.date",
-};
-// Four digits, hyphen, two digits, hyphen, two digits
-export const DAY_ISO_ID_CHARS = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
-export const DayIsoId = v.pipe(v.string(DayIsoIdError.Type), v.regex(DAY_ISO_ID_CHARS, DayIsoIdError.BadChars), v.check((value) => isValid(parseISO(value)), DayIsoIdError.InvalidDate), 
-// Stryker disable next-line StringLiteral
-v.brand("DayIsoId"));

package/dist/day.vo.d.ts

@@ -1,16 +0,0 @@
-import { DateRange } from "./date-range.vo";
-import { type DayIsoIdType } from "./day-iso-id.vo";
-import type { IntegerType } from "./integer.vo";
-import { Timestamp } from "./timestamp.vo";
-import type { TimestampValueType } from "./timestamp-value.vo";
-export declare class Day extends DateRange {
-    static fromTimestamp(timestamp: Timestamp): Day;
-    static fromTimestampValue(timestamp: TimestampValueType): Day;
-    static fromNow(now: Timestamp): Day;
-    static fromIsoId(isoId: DayIsoIdType): Day;
-    toIsoId(): DayIsoIdType;
-    previous(): Day;
-    next(): Day;
-    shift(count: IntegerType): Day;
-    toString(): string;
-}

package/dist/day.vo.js

@@ -1,43 +0,0 @@
-import { formatISO } from "date-fns";
-import * as v from "valibot";
-import { DateRange } from "./date-range.vo";
-import { DayIsoId } from "./day-iso-id.vo";
-import { Duration } from "./duration.service";
-import { Int } from "./int.vo";
-import { Timestamp } from "./timestamp.vo";
-export class Day extends DateRange {
-    static fromTimestamp(timestamp) {
-        const date = new Date(timestamp.ms);
-        const startUtc = Timestamp.fromNumber(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
-        const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
-        return new Day(startUtc, endUtc);
-    }
-    static fromTimestampValue(timestamp) {
-        return Day.fromTimestamp(Timestamp.fromValue(timestamp));
-    }
-    static fromNow(now) {
-        return Day.fromTimestamp(now);
-    }
-    static fromIsoId(isoId) {
-        const [year, month, day] = v.parse(DayIsoId, isoId).split("-").map(Number);
-        const startUtc = Timestamp.fromNumber(Date.UTC(year, month - 1, day));
-        const endUtc = startUtc.add(Duration.Days(1)).subtract(Duration.Ms(1));
-        return new Day(startUtc, endUtc);
-    }
-    toIsoId() {
-        const midday = this.getStart().add(Duration.Hours(12));
-        return v.parse(DayIsoId, formatISO(midday.ms, { representation: "date" }));
-    }
-    previous() {
-        return this.shift(Int.of(-1));
-    }
-    next() {
-        return this.shift(Int.of(1));
-    }
-    shift(count) {
-        return Day.fromTimestamp(this.getStart().add(Duration.Days(count)));
-    }
-    toString() {
-        return this.toIsoId();
-    }
-}

package/dist/directory-path-absolute.vo.d.ts

@@ -1,12 +0,0 @@
-import * as v from "valibot";
-export declare const DirectoryPathAbsoluteError: {
-    BadSegments: string;
-    Empty: string;
-    LeadingSlash: string;
-    TooLong: string;
-    TrailingSlash: string;
-    Type: string;
-};
-export declare const DIRECTORY_PATH_ABSOLUTE_CHARS: RegExp;
-export declare const DirectoryPathAbsoluteSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 512, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "DirectoryPathAbsoluteSchema">]>;
-export type DirectoryPathAbsoluteType = v.InferOutput<typeof DirectoryPathAbsoluteSchema>;

package/dist/directory-path-absolute.vo.js

@@ -1,20 +0,0 @@
-import * as v from "valibot";
-export const DirectoryPathAbsoluteError = {
-    BadSegments: "directory.path.absolue.bad.segments",
-    Empty: "directory.path.absolue.empty",
-    LeadingSlash: "directory.path.absolue.leading.slash",
-    TooLong: "directory.path.absolue.too.long",
-    TrailingSlash: "directory.path.absolue.trailing.slash",
-    Type: "directory.path.absolue.type",
-};
-// Letters, digits, dots, underscores, and hyphens
-export const DIRECTORY_PATH_ABSOLUTE_CHARS = /^[a-zA-Z0-9._-]+$/;
-const DOT_SEGMENTS = [".", ".."];
-export const DirectoryPathAbsoluteSchema = v.pipe(v.string(DirectoryPathAbsoluteError.Type), v.minLength(1, DirectoryPathAbsoluteError.Empty), v.maxLength(512, DirectoryPathAbsoluteError.TooLong), v.check((value) => value.startsWith("/"), DirectoryPathAbsoluteError.LeadingSlash), v.check((value) => (value === "/" ? true : !value.endsWith("/")), DirectoryPathAbsoluteError.TrailingSlash), v.check((value) => {
-    if (value === "/")
-        return true;
-    const segments = value.slice(1).split("/");
-    return segments.every((segment) => DIRECTORY_PATH_ABSOLUTE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment));
-}, DirectoryPathAbsoluteError.BadSegments), 
-// Stryker disable next-line StringLiteral
-v.brand("DirectoryPathAbsoluteSchema"));

package/dist/directory-path-relative.vo.d.ts

@@ -1,12 +0,0 @@
-import * as v from "valibot";
-export declare const DirectoryPathRelativeError: {
-    BadSegments: string;
-    Empty: string;
-    LeadingSlash: string;
-    TooLong: string;
-    TrailingSlash: string;
-    Type: string;
-};
-export declare const DIRECTORY_PATH_RELATIVE_CHARS: RegExp;
-export declare const DirectoryPathRelativeSchema: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 512, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.CheckAction<string, string>, v.BrandAction<string, "DirectoryPathRelativeSchema">]>;
-export type DirectoryPathRelativeType = v.InferOutput<typeof DirectoryPathRelativeSchema>;

package/dist/directory-path-relative.vo.js

@@ -1,17 +0,0 @@
-import * as v from "valibot";
-export const DirectoryPathRelativeError = {
-    BadSegments: "directory.path.relative.bad.segments",
-    Empty: "directory.path.relative.empty",
-    LeadingSlash: "directory.path.relative.leading.slash",
-    TooLong: "directory.path.absolue.too.long",
-    TrailingSlash: "directory.path.absolue.trailing.slash",
-    Type: "directory.path.relative.type",
-};
-// Letters, digits, dots, underscores, and hyphens
-export const DIRECTORY_PATH_RELATIVE_CHARS = /^[A-Za-z0-9._-]+$/;
-const DOT_SEGMENTS = [".", ".."];
-export const DirectoryPathRelativeSchema = v.pipe(v.string(DirectoryPathRelativeError.Type), v.minLength(1, DirectoryPathRelativeError.Empty), v.maxLength(512, DirectoryPathRelativeError.TooLong), v.check((value) => !value.startsWith("/"), DirectoryPathRelativeError.LeadingSlash), v.check((value) => !value.endsWith("/"), DirectoryPathRelativeError.TrailingSlash), v.check((value) => value
-    .split("/")
-    .every((segment) => DIRECTORY_PATH_RELATIVE_CHARS.test(segment) && !DOT_SEGMENTS.includes(segment)), DirectoryPathRelativeError.BadSegments), 
-// Stryker disable next-line StringLiteral
-v.brand("DirectoryPathRelativeSchema"));

package/dist/distance-value.vo.d.ts

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export declare const DistanceValueError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const DistanceValue: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>, v.BrandAction<number, "DistanceValue">]>;
-export type DistanceValueType = v.InferOutput<typeof DistanceValue>;

package/dist/distance-value.vo.js

@@ -1,5 +0,0 @@
-import * as v from "valibot";
-export const DistanceValueError = { Type: "distance.value.type", Invalid: "distance.value.invalid" };
-export const DistanceValue = v.pipe(v.number(DistanceValueError.Type), v.integer(DistanceValueError.Type), v.minValue(0, DistanceValueError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("DistanceValue"));

package/dist/distance.vo.d.ts

@@ -1,23 +0,0 @@
-import { type DistanceValueType } from "./distance-value.vo";
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare const DistanceError: {
-    SubtractResultLessThanZero: string;
-};
-export declare class Distance {
-    private readonly value;
-    private static readonly ZERO;
-    private constructor();
-    static fromMeters(candidate: number): Distance;
-    static fromMetersSafe(candidate: DistanceValueType): Distance;
-    static fromKilometers(candidate: number, rounding?: RoundingStrategy): Distance;
-    static fromMiles(candidate: number, rounding?: RoundingStrategy): Distance;
-    get(): DistanceValueType;
-    add(distance: Distance): Distance;
-    subtract(distance: Distance): Distance;
-    equals(another: Distance): boolean;
-    isLongerThan(another: Distance): boolean;
-    isShorterThan(another: Distance): boolean;
-    isZero(): boolean;
-    toString(): string;
-    toJSON(): number;
-}

package/dist/distance.vo.js

@@ -1,53 +0,0 @@
-import * as v from "valibot";
-import { DistanceValue } from "./distance-value.vo";
-import { RoundingToNearestStrategy } from "./rounding-to-nearest.strategy";
-export const DistanceError = { SubtractResultLessThanZero: "distance.subtract.result.less.than.zero" };
-export class Distance {
-    value;
-    static ZERO = v.parse(DistanceValue, 0);
-    constructor(value) {
-        this.value = value;
-    }
-    static fromMeters(candidate) {
-        return new Distance(v.parse(DistanceValue, candidate));
-    }
-    static fromMetersSafe(candidate) {
-        return new Distance(candidate);
-    }
-    static fromKilometers(candidate, rounding = new RoundingToNearestStrategy()) {
-        return new Distance(v.parse(DistanceValue, rounding.round(candidate * 1000)));
-    }
-    static fromMiles(candidate, rounding = new RoundingToNearestStrategy()) {
-        return new Distance(v.parse(DistanceValue, rounding.round(candidate * 1_609.344)));
-    }
-    get() {
-        return this.value;
-    }
-    add(distance) {
-        return new Distance(v.parse(DistanceValue, this.value + distance.get()));
-    }
-    subtract(distance) {
-        const result = this.value - distance.get();
-        if (result < Distance.ZERO)
-            throw new Error(DistanceError.SubtractResultLessThanZero);
-        return new Distance(v.parse(DistanceValue, result));
-    }
-    equals(another) {
-        return this.value === another.get();
-    }
-    isLongerThan(another) {
-        return this.value > another.get();
-    }
-    isShorterThan(another) {
-        return this.value < another.get();
-    }
-    isZero() {
-        return this.value === Distance.ZERO;
-    }
-    toString() {
-        return this.value.toString();
-    }
-    toJSON() {
-        return this.value;
-    }
-}

package/dist/division-factor.vo.d.ts

@@ -1,7 +0,0 @@
-import * as v from "valibot";
-export declare const DivisionFactorError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const DivisionFactor: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.GtValueAction<number, 0, string>, v.BrandAction<number, "DivisionFactor">]>;
-export type DivisionFactorType = v.InferOutput<typeof DivisionFactor>;

package/dist/division-factor.vo.js

@@ -1,5 +0,0 @@
-import * as v from "valibot";
-export const DivisionFactorError = { Type: "division.factor.type", Invalid: "division.factor.invalid" };
-export const DivisionFactor = v.pipe(v.number(DivisionFactorError.Type), v.gtValue(0, DivisionFactorError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("DivisionFactor"));

package/dist/dll.service.d.ts

@@ -1,29 +0,0 @@
-export declare class Node<T> {
-    data: T;
-    prev: Node<T> | null;
-    next: Node<T> | null;
-    constructor(data: Node<T>["data"]);
-    forward(n: number): Node<T> | null;
-    backward(n: number): Node<T> | null;
-}
-export declare class DoublyLinkedList<T> {
-    static EMPTY_SIZE: number;
-    private size;
-    private head;
-    private tail;
-    getSize(): DoublyLinkedList<T>["size"];
-    isEmpty(): boolean;
-    getHead(): DoublyLinkedList<T>["head"];
-    getTail(): DoublyLinkedList<T>["tail"];
-    append(node: Node<T>): void;
-    prepend(node: Node<T>): void;
-    clear(): void;
-    remove(node: Node<T>): void;
-    insertAfter(node: Node<T>, target: Node<T>): void;
-    insertBefore(node: Node<T>, target: Node<T>): void;
-    find(callback: (node: Node<T>) => boolean): Node<T> | null;
-    reverse(): void;
-    toArray(): ReadonlyArray<Node<T>>;
-    static fromArray<T>(array: ReadonlyArray<T>): DoublyLinkedList<T>;
-    [Symbol.iterator](): IterableIterator<Node<T>>;
-}