@catbee/utils 0.0.8-rc.1 → 0.0.8-rc.2

package/build/esm/utils/response.utils.js

@@ -21,21 +21,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 import { getRequestId } from './context-store.utils';
 import { Env } from './env.utils';
 import { uuid } from './id.utils';
@@ -45,70 +30,74 @@ import { uuid } from './id.utils';
  *
  * @typeParam T - The shape of the data returned in the response.
  */
-var SuccessResponse = /** @class */ (function () {
+export class SuccessResponse {
+    /** Message describing the result of the operation. */
+    message = 'Success';
+    /** Whether the response is an error. Always false in success responses. */
+    error = false;
+    /** The payload returned from the API. */
+    data = null;
+    /** Timestamp when the response was generated, in ISO format. */
+    timestamp = new Date().toISOString();
+    /** Unique identifier for this response, useful for request tracing. */
+    requestId = getRequestId() ?? uuid();
     /**
      * Constructs a new success response.
      *
      * @param {string} message - Optional message to override the default.
      * @param {T} [data] - Optional data payload.
      */
-    function SuccessResponse(message, data) {
-        var _a;
-        /** Message describing the result of the operation. */
-        this.message = 'Success';
-        /** Whether the response is an error. Always false in success responses. */
-        this.error = false;
-        /** The payload returned from the API. */
-        this.data = null;
-        /** Timestamp when the response was generated, in ISO format. */
-        this.timestamp = new Date().toISOString();
-        /** Unique identifier for this response, useful for request tracing. */
-        this.requestId = (_a = getRequestId()) !== null && _a !== void 0 ? _a : uuid();
+    constructor(message, data) {
         if (message)
             this.message = message;
-        this.data = data !== null && data !== void 0 ? data : null;
+        this.data = data ?? null;
     }
-    return SuccessResponse;
-}());
-export { SuccessResponse };
+}
 /**
  * Wrapper for error responses that extends the native `Error` object.
  * Implements `ApiResponse` but omits the `data` field (which should not be present in errors).
  */
-var ErrorResponse = /** @class */ (function (_super) {
-    __extends(ErrorResponse, _super);
+export class ErrorResponse extends Error {
+    /** HTTP status code associated with the error (e.g., 404, 500). */
+    status;
+    /** Indicates that this is an error. Always true. */
+    error = true;
+    /** Timestamp when the error occurred, in ISO format. */
+    timestamp = new Date().toISOString();
+    /** Unique identifier for this error instance. */
+    requestId = getRequestId() ?? uuid();
     /**
      * Constructs a new error response.
      *
      * @param {string} message - The error message to display or log.
      * @param {number} [status=500] - Optional HTTP status code (defaults to 500).
      */
-    function ErrorResponse(message, status) {
-        if (status === void 0) { status = 500; }
-        var _a;
-        var _this = _super.call(this, message) || this;
-        /** Indicates that this is an error. Always true. */
-        _this.error = true;
-        /** Timestamp when the error occurred, in ISO format. */
-        _this.timestamp = new Date().toISOString();
-        /** Unique identifier for this error instance. */
-        _this.requestId = (_a = getRequestId()) !== null && _a !== void 0 ? _a : uuid();
-        _this.status = status;
-        _this.name = _this.constructor.name;
-        Error.captureStackTrace(_this, _this.constructor);
-        return _this;
+    constructor(message, status = 500) {
+        super(message);
+        this.status = status;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
     }
-    return ErrorResponse;
-}(Error));
-export { ErrorResponse };
+}
 /**
  * Response with paginated data extending the standard success response.
  * Useful for APIs that return large collections of data.
  *
  * @typeParam T - The shape of each item in the paginated collection.
  */
-var PaginatedResponse = /** @class */ (function (_super) {
-    __extends(PaginatedResponse, _super);
+export class PaginatedResponse extends SuccessResponse {
+    /** Total number of items across all pages */
+    total;
+    /** Current page number (1-based) */
+    page;
+    /** Number of items per page */
+    pageSize;
+    /** Total number of pages */
+    totalPages;
+    /** Whether there's a next page available */
+    hasNext;
+    /** Whether there's a previous page available */
+    hasPrevious;
     /**
      * Constructs a new paginated response.
      *
@@ -119,60 +108,52 @@ var PaginatedResponse = /** @class */ (function (_super) {
      * @param {number} pagination.pageSize - Number of items per page.
      * @param {string} [message="Success"] - Optional custom message.
      */
-    function PaginatedResponse(items, pagination, message) {
-        if (message === void 0) { message = 'Success'; }
-        var _this = _super.call(this, message, items) || this;
-        _this.total = pagination.total;
-        _this.page = pagination.page;
-        _this.pageSize = pagination.pageSize;
-        _this.totalPages = Math.ceil(_this.total / _this.pageSize);
-        _this.hasNext = _this.page < _this.totalPages;
-        _this.hasPrevious = _this.page > 1;
-        return _this;
+    constructor(items, pagination, message = 'Success') {
+        super(message, items);
+        this.total = pagination.total;
+        this.page = pagination.page;
+        this.pageSize = pagination.pageSize;
+        this.totalPages = Math.ceil(this.total / this.pageSize);
+        this.hasNext = this.page < this.totalPages;
+        this.hasPrevious = this.page > 1;
     }
-    return PaginatedResponse;
-}(SuccessResponse));
-export { PaginatedResponse };
+}
 /**
  * Specialized response for operations that don't return data (HTTP 204).
  */
-var NoContentResponse = /** @class */ (function (_super) {
-    __extends(NoContentResponse, _super);
+export class NoContentResponse extends SuccessResponse {
     /**
      * Constructs a new no-content response.
      *
      * @param {string} [message="Operation completed successfully"] - Optional custom message.
      */
-    function NoContentResponse(message) {
-        if (message === void 0) { message = 'Operation completed successfully'; }
-        return _super.call(this, message, null) || this;
+    constructor(message = 'Operation completed successfully') {
+        super(message, null);
     }
-    return NoContentResponse;
-}(SuccessResponse));
-export { NoContentResponse };
+}
 /**
  * Specialized response for redirects.
  */
-var RedirectResponse = /** @class */ (function () {
+export class RedirectResponse {
+    /** The URL to redirect to */
+    redirectUrl;
+    /** HTTP status code for the redirect (301, 302, 303, 307, 308) */
+    statusCode;
+    /** Whether the response is a redirect */
+    isRedirect = true;
+    /** Unique identifier for this response */
+    requestId = getRequestId() ?? uuid();
     /**
      * Constructs a new redirect response.
      *
      * @param {string} url - The URL to redirect to.
      * @param {number} [statusCode=302] - HTTP status code for the redirect.
      */
-    function RedirectResponse(url, statusCode) {
-        if (statusCode === void 0) { statusCode = 302; }
-        var _a;
-        /** Whether the response is a redirect */
-        this.isRedirect = true;
-        /** Unique identifier for this response */
-        this.requestId = (_a = getRequestId()) !== null && _a !== void 0 ? _a : uuid();
+    constructor(url, statusCode = 302) {
         this.redirectUrl = url;
         this.statusCode = statusCode;
     }
-    return RedirectResponse;
-}());
-export { RedirectResponse };
+}
 /**
  * Creates a standard success response.
  *
@@ -181,8 +162,7 @@ export { RedirectResponse };
  * @param {string} [message="Success"] - Optional custom message.
  * @returns {SuccessResponse<T>} A properly formatted success response.
  */
-export function createSuccessResponse(data, message) {
-    if (message === void 0) { message = 'Success'; }
+export function createSuccessResponse(data, message = 'Success') {
     return new SuccessResponse(message, data);
 }
 /**
@@ -192,8 +172,7 @@ export function createSuccessResponse(data, message) {
  * @param {number} [statusCode=500] - HTTP status code for the error.
  * @returns {ErrorResponse} A properly formatted error response.
  */
-export function createErrorResponse(message, statusCode) {
-    if (statusCode === void 0) { statusCode = 500; }
+export function createErrorResponse(message, statusCode = 500) {
     return new ErrorResponse(message, statusCode);
 }
 /**
@@ -207,19 +186,19 @@ export function createErrorResponse(message, statusCode) {
  * @returns A properly formatted final error response.
  */
 export function createFinalErrorResponse(req, status, message, error, options) {
-    var isDev = Env.isDev();
-    var includeDetails = (options === null || options === void 0 ? void 0 : options.includeDetails) && isDev;
-    var response = {
+    const isDev = Env.isDev();
+    const includeDetails = options?.includeDetails && isDev;
+    const response = {
         error: true,
-        message: message,
+        message,
         timestamp: new Date().toISOString(),
-        requestId: (error === null || error === void 0 ? void 0 : error.requestId) || (req === null || req === void 0 ? void 0 : req.id) || uuid(),
-        status: status,
+        requestId: error?.requestId || req?.id || uuid(),
+        status,
         path: req.originalUrl || req.url
     };
     // Include stack trace in development mode if requested
-    if (includeDetails && (error === null || error === void 0 ? void 0 : error.stack)) {
-        response.stack = error.stack.split('\n').map(function (line) { return line.trim(); });
+    if (includeDetails && error?.stack) {
+        response.stack = error.stack.split('\n').map((line) => line.trim());
     }
     return response;
 }
@@ -233,16 +212,15 @@ export function createFinalErrorResponse(req, status, message, error, options) {
  * @param {string} [message="Success"] - Optional custom message.
  * @returns {PaginatedResponse<T>} A properly formatted paginated response.
  */
-export function createPaginatedResponse(allItems, page, pageSize, message) {
-    if (message === void 0) { message = 'Success'; }
+export function createPaginatedResponse(allItems, page, pageSize, message = 'Success') {
     // Ensure valid pagination parameters
-    var validPage = Math.max(1, page);
-    var validPageSize = Math.max(1, pageSize);
+    const validPage = Math.max(1, page);
+    const validPageSize = Math.max(1, pageSize);
     // Calculate slice indices
-    var startIndex = (validPage - 1) * validPageSize;
-    var endIndex = startIndex + validPageSize;
+    const startIndex = (validPage - 1) * validPageSize;
+    const endIndex = startIndex + validPageSize;
     // Get current page items
-    var pageItems = allItems.slice(startIndex, endIndex);
+    const pageItems = allItems.slice(startIndex, endIndex);
     return new PaginatedResponse(pageItems, {
         total: allItems.length,
         page: validPage,
@@ -263,7 +241,7 @@ export function sendResponse(res, apiResponse) {
     }
     // Handle errors
     if ('error' in apiResponse && apiResponse.error) {
-        var errorResponse = apiResponse;
+        const errorResponse = apiResponse;
         res.status(errorResponse.status).json({
             error: true,
             message: errorResponse.message,
@@ -273,7 +251,7 @@ export function sendResponse(res, apiResponse) {
         return;
     }
     // Handle success responses
-    var successResponse = apiResponse;
+    const successResponse = apiResponse;
     // No content (204) shouldn't return a body
     if (successResponse instanceof NoContentResponse) {
         res.status(204).end();
@@ -281,4 +259,3 @@ export function sendResponse(res, apiResponse) {
     }
     res.status(200).json(successResponse);
 }
-//# sourceMappingURL=response.utils.js.map

package/build/esm/utils/stream.utils.d.ts

@@ -85,4 +85,3 @@ export declare function createLineStream(options?: {
     encoding?: BufferEncoding;
     includeNewlines?: boolean;
 }): Transform;
-//# sourceMappingURL=stream.utils.d.ts.map

package/build/esm/utils/stream.utils.js

@@ -21,53 +21,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 import { Readable, Transform } from 'stream';
 /**
  * Convert a buffer or string to a readable stream.
@@ -83,7 +36,7 @@ import { Readable, Transform } from 'stream';
  * ```
  */
 export function bufferToStream(data) {
-    var readable = new Readable();
+    const readable = new Readable();
     readable.push(data);
     readable.push(null); // End of stream
     return readable;
@@ -100,16 +53,12 @@ export function bufferToStream(data) {
  * console.log(buffer.toString()); // Contents of file.txt
  * ```
  */
-export function streamToBuffer(stream) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve, reject) {
-                    var chunks = [];
-                    stream.on('data', function (chunk) { return chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)); });
-                    stream.on('end', function () { return resolve(Buffer.concat(chunks)); });
-                    stream.on('error', reject);
-                })];
-        });
+export async function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', chunk => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        stream.on('end', () => resolve(Buffer.concat(chunks)));
+        stream.on('error', reject);
     });
 }
 /**
@@ -125,19 +74,9 @@ export function streamToBuffer(stream) {
  * console.log(content); // Contents of file.txt as string
  * ```
  */
-export function streamToString(stream_1) {
-    return __awaiter(this, arguments, void 0, function (stream, encoding) {
-        var buffer;
-        if (encoding === void 0) { encoding = 'utf8'; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, streamToBuffer(stream)];
-                case 1:
-                    buffer = _a.sent();
-                    return [2 /*return*/, buffer.toString(encoding)];
-            }
-        });
-    });
+export async function streamToString(stream, encoding = 'utf8') {
+    const buffer = await streamToBuffer(stream);
+    return buffer.toString(encoding);
 }
 /**
  * Create a transform stream that limits the rate of data flow.
@@ -146,13 +85,13 @@ export function streamToString(stream_1) {
  * @returns Transform stream that throttles data flow
  */
 export function createThrottleStream(bytesPerSecond) {
-    var bytesSent = 0;
-    var startTime = Date.now();
+    let bytesSent = 0;
+    let startTime = Date.now();
     return new Transform({
-        transform: function (chunk, _encoding, callback) {
-            var elapsedSeconds = (Date.now() - startTime) / 1000;
-            var targetBytes = bytesPerSecond * elapsedSeconds;
-            var chunkSize = chunk.length;
+        transform(chunk, _encoding, callback) {
+            const elapsedSeconds = (Date.now() - startTime) / 1000;
+            const targetBytes = bytesPerSecond * elapsedSeconds;
+            const chunkSize = chunk.length;
             // If we've sent fewer bytes than our target, just send the chunk
             if (bytesSent + chunkSize <= targetBytes) {
                 bytesSent += chunkSize;
@@ -160,8 +99,8 @@ export function createThrottleStream(bytesPerSecond) {
                 return;
             }
             // Otherwise we need to throttle
-            var delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1000;
-            setTimeout(function () {
+            const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1000;
+            setTimeout(() => {
                 bytesSent += chunkSize;
                 callback(null, chunk);
             }, delay);
@@ -184,15 +123,14 @@ export function createThrottleStream(bytesPerSecond) {
  *   .on('data', batch => console.log(`Processing batch of ${batch.length} lines`));
  * ```
  */
-export function createBatchStream(size, options) {
-    if (options === void 0) { options = {}; }
-    var objectMode = options.objectMode !== false;
-    var batch = [];
-    var buffers = [];
-    var bufferSize = 0;
+export function createBatchStream(size, options = {}) {
+    const objectMode = options.objectMode !== false;
+    let batch = [];
+    let buffers = [];
+    let bufferSize = 0;
     return new Transform({
-        objectMode: objectMode,
-        transform: function (chunk, _encoding, callback) {
+        objectMode,
+        transform(chunk, _encoding, callback) {
             if (objectMode) {
                 batch.push(chunk);
                 if (batch.length >= size) {
@@ -201,11 +139,11 @@ export function createBatchStream(size, options) {
                 }
             }
             else {
-                var buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                 buffers.push(buffer);
                 bufferSize += buffer.length;
                 // Emit batches of exact size
-                var combined = Buffer.concat(buffers, bufferSize);
+                let combined = Buffer.concat(buffers, bufferSize);
                 while (combined.length >= size) {
                     this.push(combined.slice(0, size));
                     combined = combined.slice(size);
@@ -215,12 +153,12 @@ export function createBatchStream(size, options) {
             }
             callback();
         },
-        flush: function (callback) {
+        flush(callback) {
             if (objectMode && batch.length > 0) {
                 this.push(batch);
             }
             else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
-                var combined = Buffer.concat(buffers, bufferSize);
+                let combined = Buffer.concat(buffers, bufferSize);
                 while (combined.length >= size) {
                     this.push(combined.slice(0, size));
                     combined = combined.slice(size);
@@ -247,33 +185,21 @@ export function createBatchStream(size, options) {
  *   .on('data', line => console.log(`Line: ${line}`));
  * ```
  */
-export function createLineStream(options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.encoding, encoding = _a === void 0 ? 'utf8' : _a, _b = options.includeNewlines, includeNewlines = _b === void 0 ? false : _b;
-    var buffer = '';
+export function createLineStream(options = {}) {
+    const { encoding = 'utf8', includeNewlines = false } = options;
+    let buffer = '';
     return new Transform({
         objectMode: true,
-        transform: function (chunk, _encoding, callback) {
-            var e_1, _a;
-            var str = buffer + (Buffer.isBuffer(chunk) ? chunk.toString(encoding) : chunk);
-            var lines = str.split(/\r?\n/);
+        transform(chunk, _encoding, callback) {
+            const str = buffer + (Buffer.isBuffer(chunk) ? chunk.toString(encoding) : chunk);
+            const lines = str.split(/\r?\n/);
             buffer = lines.pop() || '';
-            try {
-                for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
-                    var line = lines_1_1.value;
-                    this.push(includeNewlines ? line + '\n' : line);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (lines_1_1 && !lines_1_1.done && (_a = lines_1.return)) _a.call(lines_1);
-                }
-                finally { if (e_1) throw e_1.error; }
+            for (const line of lines) {
+                this.push(includeNewlines ? line + '\n' : line);
             }
             callback();
         },
-        flush: function (callback) {
+        flush(callback) {
             if (buffer) {
                 this.push(buffer);
             }
@@ -281,4 +207,3 @@ export function createLineStream(options) {
         }
     });
 }
-//# sourceMappingURL=stream.utils.js.map

package/build/esm/utils/string.utils.d.ts

@@ -90,4 +90,3 @@ export declare function reverse(str: string): string;
  * @returns {number} Number of occurrences.
  */
 export declare function countOccurrences(str: string, substring: string, caseSensitive?: boolean): number;
-//# sourceMappingURL=string.utils.d.ts.map

package/build/esm/utils/string.utils.js

@@ -50,7 +50,7 @@ export function toKebabCase(str) {
  * @returns {string} The camelCased string.
  */
 export function toCamelCase(str) {
-    return str.replace(/[-_](.)/g, function (_, c) { return c.toUpperCase(); });
+    return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase());
 }
 /**
  * Converts a string to a URL-friendly slug (lowercase, dashes, alphanumeric).
@@ -109,17 +109,14 @@ export function toSnakeCase(str) {
  * @param {string} [maskChar="*"] - Character to use for masking.
  * @returns {string} The masked string.
  */
-export function mask(str, visibleStart, visibleEnd, maskChar) {
-    if (visibleStart === void 0) { visibleStart = 0; }
-    if (visibleEnd === void 0) { visibleEnd = 0; }
-    if (maskChar === void 0) { maskChar = '*'; }
+export function mask(str, visibleStart = 0, visibleEnd = 0, maskChar = '*') {
     if (!str || str.length === 0)
         return '';
     if (visibleStart >= str.length)
         return str;
-    var start = str.slice(0, visibleStart);
-    var end = visibleEnd > 0 ? str.slice(-visibleEnd) : '';
-    var masked = maskChar.repeat(Math.max(0, str.length - visibleStart - visibleEnd));
+    const start = str.slice(0, visibleStart);
+    const end = visibleEnd > 0 ? str.slice(-visibleEnd) : '';
+    const masked = maskChar.repeat(Math.max(0, str.length - visibleStart - visibleEnd));
     return start + masked + end;
 }
 /**
@@ -158,12 +155,10 @@ export function reverse(str) {
  * @param {boolean} [caseSensitive=true] - Whether to perform case-sensitive counting.
  * @returns {number} Number of occurrences.
  */
-export function countOccurrences(str, substring, caseSensitive) {
-    if (caseSensitive === void 0) { caseSensitive = true; }
+export function countOccurrences(str, substring, caseSensitive = true) {
     if (!caseSensitive) {
         str = str.toLowerCase();
         substring = substring.toLowerCase();
     }
     return str.split(substring).length - 1;
 }
-//# sourceMappingURL=string.utils.js.map

package/build/esm/utils/type.utils.d.ts

@@ -87,4 +87,3 @@ export declare function toBool(value: unknown, defaultValue?: boolean): boolean;
  * ```
  */
 export declare function ensureType<T>(value: unknown, expectedType: string, defaultValue: T): T;
-//# sourceMappingURL=type.utils.d.ts.map