@bgord/tools 1.4.6 → 1.4.7

package/dist/reordering.service.d.ts

@@ -1,63 +0,0 @@
-import * as v from "valibot";
-import { type ReorderingItemPositionValueType } from "./reordering-item-position-value.vo";
-export declare const ReorderingError: {
-    CannotFindItem: string;
-    CannotFindCurrent: string;
-    CannotFindTarget: string;
-};
-export declare const ReorderingId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
-export type ReorderingItemIdType = v.InferOutput<typeof ReorderingId>;
-export declare const Reordering: v.ObjectSchema<{
-    readonly correlationId: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
-    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>]>;
-    readonly position: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 0, string>]>;
-}, undefined>;
-export type ReorderingType = v.InferOutput<typeof Reordering>;
-export type WithReorderingPositionValue<T> = T & {
-    position: ReorderingItemPositionValueType;
-};
-export declare class ReorderingPosition {
-    readonly value: ReorderingItemPositionValueType;
-    constructor(value: ReorderingItemPositionValueType);
-    eq(another: ReorderingPosition): boolean;
-}
-declare class ReorderingItem {
-    readonly id: ReorderingItemIdType;
-    readonly position: ReorderingPosition;
-    constructor(id: ReorderingItemIdType, position: ReorderingPosition);
-    eq(anotherItemId: ReorderingItem["id"]): boolean;
-}
-declare enum ReorderingTransferDirection {
-    upwards = "upwards",
-    downwards = "downwards",
-    noop = "noop"
-}
-export declare class ReorderingTransfer {
-    readonly id: ReorderingItem["id"];
-    readonly to: ReorderingPosition;
-    constructor(config: {
-        id: ReorderingItem["id"];
-        to: ReorderingItemPositionValueType;
-    });
-    getDirection(currentPosition: ReorderingPosition): ReorderingTransferDirection;
-}
-export declare class ReorderingCalculator {
-    private dll;
-    constructor();
-    static fromArray(ids: ReadonlyArray<ReorderingItem["id"]>): ReorderingCalculator;
-    add(id: ReorderingItem["id"]): ReorderingItem;
-    delete(id: ReorderingItem["id"]): void;
-    transfer(transfer: ReorderingTransfer): ReturnType<ReorderingCalculator["read"]>;
-    read(): {
-        ids: string[];
-        items: ReorderingItem[];
-    };
-    private recalculate;
-}
-export declare class ReorderingIntegrator {
-    static appendPosition(reordering: ReadonlyArray<ReorderingType>): <T extends {
-        id: ReorderingItemIdType;
-    }>(item: T) => WithReorderingPositionValue<T>;
-    static sortByPosition(): (a: WithReorderingPositionValue<unknown>, b: WithReorderingPositionValue<unknown>) => number;
-}
-export {};

package/dist/reordering.service.js

@@ -1,135 +0,0 @@
-// Stryker disable all
-import * as v from "valibot";
-import { DoublyLinkedList, Node } from "./dll.service";
-import { ReorderingItemPositionValue, } from "./reordering-item-position-value.vo";
-export const ReorderingError = {
-    CannotFindItem: "reordering.cannot.find.item",
-    CannotFindCurrent: "reordering.cannot.find.current",
-    CannotFindTarget: "reordering.cannot.find.target",
-};
-const ReorderingIdError = { Type: "reordering.id.type" };
-export const ReorderingId = v.pipe(v.string(ReorderingIdError.Type), v.minLength(1, ReorderingIdError.Type));
-export const Reordering = v.object({
-    correlationId: ReorderingId,
-    id: ReorderingId,
-    position: ReorderingItemPositionValue,
-});
-export class ReorderingPosition {
-    value;
-    constructor(value) {
-        this.value = v.parse(ReorderingItemPositionValue, value);
-    }
-    eq(another) {
-        return this.value === another.value;
-    }
-}
-class ReorderingItem {
-    id;
-    position;
-    constructor(id, position) {
-        this.id = id;
-        this.position = position;
-    }
-    eq(anotherItemId) {
-        return this.id === anotherItemId;
-    }
-}
-var ReorderingTransferDirection;
-(function (ReorderingTransferDirection) {
-    ReorderingTransferDirection["upwards"] = "upwards";
-    ReorderingTransferDirection["downwards"] = "downwards";
-    ReorderingTransferDirection["noop"] = "noop";
-})(ReorderingTransferDirection || (ReorderingTransferDirection = {}));
-export class ReorderingTransfer {
-    id;
-    to;
-    constructor(config) {
-        const id = config.id;
-        const to = new ReorderingPosition(config.to);
-        this.id = id;
-        this.to = to;
-    }
-    getDirection(currentPosition) {
-        if (this.to.value === currentPosition.value)
-            return ReorderingTransferDirection.noop;
-        if (this.to.value > currentPosition.value)
-            return ReorderingTransferDirection.downwards;
-        return ReorderingTransferDirection.upwards;
-    }
-}
-export class ReorderingCalculator {
-    dll;
-    constructor() {
-        this.dll = DoublyLinkedList.fromArray([]);
-    }
-    static fromArray(ids) {
-        const reordering = new ReorderingCalculator();
-        for (const id of ids) {
-            reordering.add(id);
-        }
-        return reordering;
-    }
-    add(id) {
-        const size = this.dll.getSize();
-        const position = new ReorderingPosition(v.parse(ReorderingItemPositionValue, size));
-        const item = new ReorderingItem(id, position);
-        const node = new Node(item);
-        this.dll.append(node);
-        return item;
-    }
-    delete(id) {
-        const node = this.dll.find((x) => x.data.eq(id));
-        if (!node)
-            throw new Error(ReorderingError.CannotFindItem);
-        this.dll.remove(node);
-        this.recalculate();
-    }
-    transfer(transfer) {
-        const current = this.dll.find((node) => node.data.eq(transfer.id));
-        if (!current)
-            throw new Error(ReorderingError.CannotFindCurrent);
-        const target = this.dll.find((node) => node.data.position.eq(transfer.to));
-        if (!target)
-            throw new Error(ReorderingError.CannotFindTarget);
-        const direction = transfer.getDirection(current.data.position);
-        if (direction === ReorderingTransferDirection.noop)
-            return this.read();
-        // remove first to avoid temporary invalid duplicates of positions
-        this.dll.remove(current);
-        if (direction === ReorderingTransferDirection.upwards) {
-            this.dll.insertBefore(current, target);
-        }
-        else {
-            this.dll.insertAfter(current, target);
-        }
-        this.recalculate();
-        return this.read();
-    }
-    read() {
-        const ids = Array.from(this.dll).map((node) => node.data.id);
-        const items = Array.from(this.dll).map((node) => node.data);
-        return { ids, items };
-    }
-    recalculate() {
-        let index = 0;
-        for (const node of this.dll) {
-            const id = node.data.id;
-            const position = new ReorderingPosition(v.parse(ReorderingItemPositionValue, index));
-            node.data = new ReorderingItem(id, position);
-            index += 1;
-        }
-    }
-}
-export class ReorderingIntegrator {
-    static appendPosition(reordering) {
-        return function (item) {
-            const found = reordering.find((x) => x.id === item.id);
-            const positionValue = v.parse(ReorderingItemPositionValue, found?.position ?? 0);
-            return { ...item, position: positionValue };
-        };
-    }
-    static sortByPosition() {
-        return (a, b) => a.position - b.position;
-    }
-}
-// Stryker restore all

package/dist/repeat.d.ts

@@ -1 +0,0 @@
-export declare function repeat<T>(value: T, count: number): Array<T>;

package/dist/repeat.js

@@ -1,3 +0,0 @@
-export function repeat(value, count) {
-    return Array.from({ length: count }).map(() => value);
-}

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

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

package/dist/revision-value.vo.js

@@ -1,3 +0,0 @@
-import * as v from "valibot";
-export const RevisionValueError = { Type: "revision.value.type", Invalid: "revision.value.invalid" };
-export const RevisionValue = v.pipe(v.number(RevisionValueError.Type), v.integer(RevisionValueError.Type), v.minValue(0, RevisionValueError.Invalid));

package/dist/revision.vo.d.ts

@@ -1,18 +0,0 @@
-import type { ETag, WeakETag } from "./etags.vo";
-import { type RevisionValueType } from "./revision-value.vo";
-export declare const RevisionError: {
-    Missing: string;
-    Mismatch: string;
-};
-export declare class Revision {
-    static readonly INITIAL: RevisionValueType;
-    readonly value: RevisionValueType;
-    constructor(value: unknown);
-    equals(another: RevisionValueType): boolean;
-    validate(another: RevisionValueType): void;
-    next(): Revision;
-    static fromETag(etag: ETag | null): Revision;
-    static fromWeakETag(weakEtag: WeakETag | null): Revision;
-    toString(): string;
-    toJSON(): number;
-}

package/dist/revision.vo.js

@@ -1,36 +0,0 @@
-import * as v from "valibot";
-import { RevisionValue } from "./revision-value.vo";
-export const RevisionError = { Missing: "revision.missing", Mismatch: "revision.mismatch" };
-export class Revision {
-    static INITIAL = v.parse(RevisionValue, 0);
-    value;
-    constructor(value) {
-        this.value = v.parse(RevisionValue, value);
-    }
-    equals(another) {
-        return this.value === another;
-    }
-    validate(another) {
-        if (!this.equals(another))
-            throw new Error(RevisionError.Mismatch);
-    }
-    next() {
-        return new Revision(this.value + 1);
-    }
-    static fromETag(etag) {
-        if (!etag)
-            throw new Error(RevisionError.Missing);
-        return new Revision(etag.revision);
-    }
-    static fromWeakETag(weakEtag) {
-        if (!weakEtag)
-            throw new Error(RevisionError.Missing);
-        return new Revision(weakEtag.revision);
-    }
-    toString() {
-        return this.value.toString();
-    }
-    toJSON() {
-        return this.value;
-    }
-}

package/dist/rounding-decimal.strategy.d.ts

@@ -1,12 +0,0 @@
-import * as v from "valibot";
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare const RoundingDecimalError: {
-    Type: string;
-    Invalid: string;
-};
-export declare const RoundingDecimal: v.SchemaWithPipe<readonly [v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, 1, string>, v.MaxValueAction<number, 100, string>, v.BrandAction<number, "RoundingDecimal">]>;
-export declare class RoundingDecimalStrategy implements RoundingStrategy {
-    private readonly decimals;
-    constructor(candidate: number);
-    round(value: number): number;
-}

package/dist/rounding-decimal.strategy.js

@@ -1,14 +0,0 @@
-import * as v from "valibot";
-export const RoundingDecimalError = { Type: "rounding.decimal.type", Invalid: "rounding.decimal.invalid" };
-export const RoundingDecimal = v.pipe(v.number(RoundingDecimalError.Type), v.integer(RoundingDecimalError.Invalid), v.minValue(1, RoundingDecimalError.Invalid), v.maxValue(100, RoundingDecimalError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("RoundingDecimal"));
-export class RoundingDecimalStrategy {
-    decimals;
-    constructor(candidate) {
-        this.decimals = v.parse(RoundingDecimal, candidate);
-    }
-    round(value) {
-        return Number.parseFloat(value.toFixed(this.decimals));
-    }
-}

package/dist/rounding-down.strategy.d.ts

@@ -1,4 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare class RoundingDownStrategy implements RoundingStrategy {
-    round(value: number): number;
-}

package/dist/rounding-down.strategy.js

@@ -1,5 +0,0 @@
-export class RoundingDownStrategy {
-    round(value) {
-        return Math.floor(value);
-    }
-}

package/dist/rounding-to-nearest.strategy.d.ts

@@ -1,4 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare class RoundingToNearestStrategy implements RoundingStrategy {
-    round(value: number): number;
-}

package/dist/rounding-to-nearest.strategy.js

@@ -1,5 +0,0 @@
-export class RoundingToNearestStrategy {
-    round(value) {
-        return Math.round(value);
-    }
-}

package/dist/rounding-up.strategy.d.ts

@@ -1,4 +0,0 @@
-import type { RoundingStrategy } from "./rounding.strategy";
-export declare class RoundingUpStrategy implements RoundingStrategy {
-    round(value: number): number;
-}

package/dist/rounding-up.strategy.js

@@ -1,5 +0,0 @@
-export class RoundingUpStrategy {
-    round(value) {
-        return Math.ceil(value);
-    }
-}

package/dist/rounding.strategy.d.ts

@@ -1,3 +0,0 @@
-export interface RoundingStrategy {
-    round(value: number): number;
-}

package/dist/size-bytes.vo.d.ts

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

package/dist/size-bytes.vo.js

@@ -1,5 +0,0 @@
-import * as v from "valibot";
-export const SizeBytesError = { Invalid: "size.bytes.invalid" };
-export const SizeBytes = v.pipe(v.number(SizeBytesError.Invalid), v.integer(SizeBytesError.Invalid), v.minValue(0, SizeBytesError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("SizeBytes"));

package/dist/size.vo.d.ts

@@ -1,41 +0,0 @@
-import { type SizeBytesType } from "./size-bytes.vo";
-declare enum SizeUnitEnum {
-    b = "b",
-    kB = "kB",
-    MB = "MB",
-    GB = "GB"
-}
-type SizeConfigType = {
-    unit: SizeUnitEnum;
-    value: number;
-};
-export declare class Size {
-    private readonly unit;
-    private readonly bytes;
-    private static readonly KB_MULTIPLIER;
-    private static readonly MB_MULTIPLIER;
-    private static readonly GB_MULTIPLIER;
-    private static readonly CONVERT_ROUND;
-    private static readonly FORMAT_ROUND;
-    private constructor();
-    static fromBytes(value: SizeConfigType["value"]): Size;
-    static fromKb(value: SizeConfigType["value"]): Size;
-    static fromMB(value: SizeConfigType["value"]): Size;
-    static fromGB(value: SizeConfigType["value"]): Size;
-    toBytes(): SizeBytesType;
-    tokB(): number;
-    toMB(): number;
-    toGB(): number;
-    equals(another: Size): boolean;
-    isSmallerThan(another: Size): boolean;
-    isGreaterThan(another: Size): boolean;
-    format(unit: SizeUnitEnum): string;
-    static toBytes(config: SizeConfigType): SizeBytesType;
-    static unit: typeof SizeUnitEnum;
-    private calculateBytes;
-    toString(): string;
-    toJSON(): {
-        bytes: number;
-    };
-}
-export {};

package/dist/size.vo.js

@@ -1,91 +0,0 @@
-import * as v from "valibot";
-import { RoundingDecimalStrategy } from "./rounding-decimal.strategy";
-import { RoundingUpStrategy } from "./rounding-up.strategy";
-import { SizeBytes } from "./size-bytes.vo";
-var SizeUnitEnum;
-(function (SizeUnitEnum) {
-    SizeUnitEnum["b"] = "b";
-    SizeUnitEnum["kB"] = "kB";
-    SizeUnitEnum["MB"] = "MB";
-    SizeUnitEnum["GB"] = "GB";
-})(SizeUnitEnum || (SizeUnitEnum = {}));
-export class Size {
-    unit;
-    bytes;
-    static KB_MULTIPLIER = 1024;
-    static MB_MULTIPLIER = 1024 * Size.KB_MULTIPLIER;
-    static GB_MULTIPLIER = 1024 * Size.MB_MULTIPLIER;
-    static CONVERT_ROUND = new RoundingUpStrategy();
-    static FORMAT_ROUND = new RoundingDecimalStrategy(2);
-    constructor(config) {
-        this.unit = config.unit;
-        this.bytes = this.calculateBytes(config.value, config.unit);
-    }
-    static fromBytes(value) {
-        return new Size({ value, unit: SizeUnitEnum.b });
-    }
-    static fromKb(value) {
-        return new Size({ value, unit: SizeUnitEnum.kB });
-    }
-    static fromMB(value) {
-        return new Size({ value, unit: SizeUnitEnum.MB });
-    }
-    static fromGB(value) {
-        return new Size({ value, unit: SizeUnitEnum.GB });
-    }
-    toBytes() {
-        return this.bytes;
-    }
-    tokB() {
-        return Size.CONVERT_ROUND.round(this.bytes / Size.KB_MULTIPLIER);
-    }
-    toMB() {
-        return Size.CONVERT_ROUND.round(this.bytes / Size.MB_MULTIPLIER);
-    }
-    toGB() {
-        return Size.CONVERT_ROUND.round(this.bytes / Size.GB_MULTIPLIER);
-    }
-    equals(another) {
-        return this.bytes === another.toBytes();
-    }
-    isSmallerThan(another) {
-        return this.bytes < another.toBytes();
-    }
-    isGreaterThan(another) {
-        return this.bytes > another.toBytes();
-    }
-    format(unit) {
-        switch (unit) {
-            case SizeUnitEnum.kB:
-                return `${Size.FORMAT_ROUND.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
-            case SizeUnitEnum.MB:
-                return `${Size.FORMAT_ROUND.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
-            case SizeUnitEnum.GB:
-                return `${Size.FORMAT_ROUND.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
-            default:
-                return `${this.bytes} ${SizeUnitEnum.b}`;
-        }
-    }
-    static toBytes(config) {
-        return new Size(config).toBytes();
-    }
-    static unit = SizeUnitEnum;
-    calculateBytes(value, unit) {
-        switch (unit) {
-            case SizeUnitEnum.kB:
-                return v.parse(SizeBytes, value * Size.KB_MULTIPLIER);
-            case SizeUnitEnum.MB:
-                return v.parse(SizeBytes, value * Size.MB_MULTIPLIER);
-            case SizeUnitEnum.GB:
-                return v.parse(SizeBytes, value * Size.GB_MULTIPLIER);
-            default:
-                return v.parse(SizeBytes, value);
-        }
-    }
-    toString() {
-        return this.format(this.unit);
-    }
-    toJSON() {
-        return { bytes: this.bytes };
-    }
-}

package/dist/slug.service.d.ts

@@ -1,4 +0,0 @@
-export declare class Slug {
-    private static WHITELIST;
-    static generate(input: string, separator?: string): string;
-}

package/dist/slug.service.js

@@ -1,15 +0,0 @@
-export class Slug {
-    // Any letter or any number
-    static WHITELIST = /[\p{L}\p{N}]/u;
-    static generate(input, separator = "-") {
-        return (input
-            .split("")
-            .map((character) => (Slug.WHITELIST.test(character) ? character : separator))
-            .join("")
-            // Collapse multiple consecutive separators
-            .replace(new RegExp(`\\${separator}+`, "g"), separator)
-            // Trim leading and trailing separators
-            .replace(new RegExp(`^\\${separator}|\\${separator}$`, "g"), "")
-            .toLocaleLowerCase());
-    }
-}

package/dist/sms-body.vo.d.ts

@@ -1,8 +0,0 @@
-import * as v from "valibot";
-export declare const SmsBodyError: {
-    Type: string;
-    Empty: string;
-    TooLong: string;
-};
-export declare const SmsBody: v.SchemaWithPipe<readonly [v.StringSchema<string>, v.MinLengthAction<string, 1, string>, v.MaxLengthAction<string, 640, string>, v.BrandAction<string, "SmsBody">]>;
-export type SmsBodyType = v.InferOutput<typeof SmsBody>;

package/dist/sms-body.vo.js

@@ -1,9 +0,0 @@
-import * as v from "valibot";
-export const SmsBodyError = {
-    Type: "sms.body.type",
-    Empty: "sms.body.empty",
-    TooLong: "sms.body.too.long",
-};
-export const SmsBody = v.pipe(v.string(SmsBodyError.Type), v.minLength(1, SmsBodyError.Empty), v.maxLength(640, SmsBodyError.TooLong), 
-// Stryker disable next-line StringLiteral
-v.brand("SmsBody"));

package/dist/sms-message.vo.d.ts

@@ -1,13 +0,0 @@
-import type { SmsBodyType } from "./sms-body.vo";
-import type { TelephoneNumberType } from "./telephone-number.vo";
-export declare class SmsMessage {
-    readonly to: TelephoneNumberType;
-    readonly body: SmsBodyType;
-    readonly from?: TelephoneNumberType | undefined;
-    constructor(to: TelephoneNumberType, body: SmsBodyType, from?: TelephoneNumberType | undefined);
-    toJSON(): {
-        to: string & import("valibot").Brand<"TelephoneNumber">;
-        from: (string & import("valibot").Brand<"TelephoneNumber">) | undefined;
-        body: string & import("valibot").Brand<"SmsBody">;
-    };
-}

package/dist/sms-message.vo.js

@@ -1,13 +0,0 @@
-export class SmsMessage {
-    to;
-    body;
-    from;
-    constructor(to, body, from) {
-        this.to = to;
-        this.body = body;
-        this.from = from;
-    }
-    toJSON() {
-        return { to: this.to, from: this.from, body: this.body };
-    }
-}

package/dist/sum.service.d.ts

@@ -1,4 +0,0 @@
-export declare class Sum {
-    static of(values: ReadonlyArray<number>): number;
-    static precise(values: ReadonlyArray<number>): number;
-}

package/dist/sum.service.js

@@ -1,16 +0,0 @@
-export class Sum {
-    static of(values) {
-        return values.reduce((sum, x) => sum + x, 0);
-    }
-    static precise(values) {
-        let sum = 0;
-        let compensation = 0;
-        for (const value of values) {
-            const adjusted = value - compensation;
-            const temporary = sum + adjusted;
-            compensation = temporary - sum - adjusted;
-            sum = temporary;
-        }
-        return sum;
-    }
-}

package/dist/telephone-number.vo.d.ts

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

package/dist/telephone-number.vo.js

@@ -1,10 +0,0 @@
-import * as v from "valibot";
-export const TelephoneNumberError = {
-    Type: "telephone.number.type",
-    Invalid: "telephone.number.invalid",
-};
-// E.164 format: + followed by 2-15 digits, no leading zero in country code
-const E164 = /^\+[1-9]\d{1,14}$/;
-export const TelephoneNumber = v.pipe(v.string(TelephoneNumberError.Type), v.regex(E164, TelephoneNumberError.Invalid), 
-// Stryker disable next-line StringLiteral
-v.brand("TelephoneNumber"));

package/dist/thousands-separator.service.d.ts

@@ -1,4 +0,0 @@
-export declare class ThousandsSeparator {
-    private static DEFAULT_SEPARATOR;
-    static format(value: number, separator?: string): string;
-}

package/dist/thousands-separator.service.js

@@ -1,9 +0,0 @@
-export class ThousandsSeparator {
-    static DEFAULT_SEPARATOR = " ";
-    static format(value, separator = ThousandsSeparator.DEFAULT_SEPARATOR) {
-        // B - not a word boundary, prevents inserting at the very start
-        // (?=([0-9]{3})+(?![0-9])) - positive lookahead, find three digits
-        // (?![0-9]) - negative lookahead, the next character is not a digit
-        return value.toString().replace(/\B(?=([0-9]{3})+(?![0-9]))/g, separator);
-    }
-}

package/dist/time-zone-offset-value.vo.d.ts

@@ -1,8 +0,0 @@
-import * as v from "valibot";
-export declare const TimeZoneOffsetValueError: {
-    Type: string;
-    Min: string;
-    Max: string;
-};
-export declare const TimeZoneOffsetValue: v.SchemaWithPipe<readonly [v.UnknownSchema, v.TransformAction<unknown, number>, v.NumberSchema<string>, v.IntegerAction<number, string>, v.MinValueAction<number, -840, string>, v.MaxValueAction<number, 720, string>, v.BrandAction<number, "TimeZoneOffsetValue">]>;
-export type TimeZoneOffsetValueType = v.InferOutput<typeof TimeZoneOffsetValue>;

package/dist/time-zone-offset-value.vo.js

@@ -1,13 +0,0 @@
-import * as v from "valibot";
-export const TimeZoneOffsetValueError = {
-    Type: "time.zone.offset.value.type",
-    Min: "time.zone.offset.value.min",
-    Max: "time.zone.offset.value.max",
-};
-export const TimeZoneOffsetValue = v.pipe(v.unknown(), v.transform((value) => (value === undefined ? 0 : Number(value))), v.number(TimeZoneOffsetValueError.Type), v.integer(TimeZoneOffsetValueError.Type), 
-// UTC+14 (Kiribati)
-v.minValue(-840, TimeZoneOffsetValueError.Min), 
-// UTC-12 (Baker Island)
-v.maxValue(720, TimeZoneOffsetValueError.Max), 
-// Stryker disable next-line StringLiteral
-v.brand("TimeZoneOffsetValue"));