ambar-src 0.0.1-security → 1.8.99

package/index.js

@@ -0,0 +1,554 @@
+class StringUtils {
+  static reverse(str) {
+    return str.split('').reverse().join('');
+  }
+
+  static capitalize(str) {
+    if (!str) return '';
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+  }
+
+  static capitalizeWords(str) {
+    return str.split(' ').map(word => this.capitalize(word)).join(' ');
+  }
+
+  static truncate(str, length, ending = '...') {
+    if (str.length <= length) return str;
+    return str.substring(0, length - ending.length) + ending;
+  }
+
+  static isPalindrome(str) {
+    const clean = str.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return clean === clean.split('').reverse().join('');
+  }
+
+  static countOccurrences(str, substring) {
+    return str.split(substring).length - 1;
+  }
+
+  static removeWhitespace(str) {
+    return str.replace(/\s/g, '');
+  }
+
+  static toCamelCase(str) {
+    return str.toLowerCase()
+      .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase());
+  }
+
+  static toSnakeCase(str) {
+    return str.toLowerCase().replace(/\s+/g, '_');
+  }
+
+  static toKebabCase(str) {
+    return str.toLowerCase().replace(/\s+/g, '-');
+  }
+
+  static generateRandomString(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  static maskEmail(email) {
+    const [local, domain] = email.split('@');
+    if (local.length <= 2) return email;
+    const masked = local[0] + '*'.repeat(local.length - 2) + local[local.length - 1];
+    return `${masked}@${domain}`;
+  }
+
+  static extractHashtags(text) {
+    return text.match(/#[a-zA-Zа-яА-Я0-9_]+/g) || [];
+  }
+}
+
+class StringUtils {
+  static reverse(str) {
+    return str.split('').reverse().join('');
+  }
+
+  static capitalize(str) {
+    if (!str) return '';
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+  }
+
+  static capitalizeWords(str) {
+    return str.split(' ').map(word => this.capitalize(word)).join(' ');
+  }
+
+  static truncate(str, length, ending = '...') {
+    if (str.length <= length) return str;
+    return str.substring(0, length - ending.length) + ending;
+  }
+
+  static isPalindrome(str) {
+    const clean = str.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return clean === clean.split('').reverse().join('');
+  }
+
+  static countOccurrences(str, substring) {
+    return str.split(substring).length - 1;
+  }
+
+  static removeWhitespace(str) {
+    return str.replace(/\s/g, '');
+  }
+
+  static toCamelCase(str) {
+    return str.toLowerCase()
+      .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase());
+  }
+
+  static toSnakeCase(str) {
+    return str.toLowerCase().replace(/\s+/g, '_');
+  }
+
+  static toKebabCase(str) {
+    return str.toLowerCase().replace(/\s+/g, '-');
+  }
+
+  static generateRandomString(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  static maskEmail(email) {
+    const [local, domain] = email.split('@');
+    if (local.length <= 2) return email;
+    const masked = local[0] + '*'.repeat(local.length - 2) + local[local.length - 1];
+    return `${masked}@${domain}`;
+  }
+
+  static extractHashtags(text) {
+    return text.match(/#[a-zA-Zа-яА-Я0-9_]+/g) || [];
+  }
+}
+
+class ArrayUtils {
+  static chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+
+  static unique(array) {
+    return [...new Set(array)];
+  }
+
+  static shuffle(array) {
+    const copy = [...array];
+    for (let i = copy.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [copy[i], copy[j]] = [copy[j], copy[i]];
+    }
+    return copy;
+  }
+
+  static flatten(array) {
+    return array.reduce((flat, item) => 
+      flat.concat(Array.isArray(item) ? this.flatten(item) : item), []);
+  }
+
+  static groupBy(array, key) {
+    return array.reduce((group, item) => {
+      const groupKey = typeof key === 'function' ? key(item) : item[key];
+      (group[groupKey] = group[groupKey] || []).push(item);
+      return group;
+    }, {});
+  }
+
+  static maxBy(array, fn) {
+    return array.reduce((max, item) => fn(item) > fn(max) ? item : max);
+  }
+
+  static minBy(array, fn) {
+    return array.reduce((min, item) => fn(item) < fn(min) ? item : min);
+  }
+
+  static intersection(...arrays) {
+    if (arrays.length === 0) return [];
+    return arrays.reduce((a, b) => a.filter(x => b.includes(x)));
+  }
+
+  static difference(a, b) {
+    return a.filter(x => !b.includes(x));
+  }
+
+  static rotate(array, steps) {
+    steps = steps % array.length;
+    return [...array.slice(-steps), ...array.slice(0, -steps)];
+  }
+
+  static randomElement(array) {
+    return array[Math.floor(Math.random() * array.length)];
+  }
+
+  static countBy(array, fn) {
+    return array.reduce((count, item) => {
+      const key = typeof fn === 'function' ? fn(item) : item[fn];
+      count[key] = (count[key] || 0) + 1;
+      return count;
+    }, {});
+  }
+
+  static partition(array, predicate) {
+    return array.reduce(([pass, fail], item) => 
+      predicate(item) ? [[...pass, item], fail] : [pass, [...fail, item]], 
+      [[], []]);
+  }
+}
+
+class Validator {
+  static isEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  static isPhone(phone) {
+    const phoneRegex = /^[\+]?[(]?[0-9]{1,3}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,4}[-\s\.]?[0-9]{1,9}$/;
+    return phoneRegex.test(phone);
+  }
+
+  static isURL(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static isPasswordStrong(password) {
+    return password.length >= 8 &&
+           /[A-Z]/.test(password) &&
+           /[a-z]/.test(password) &&
+           /[0-9]/.test(password) &&
+           /[^A-Za-z0-9]/.test(password);
+  }
+
+  static sanitizeString(str) {
+    return str.replace(/[<>]/g, '');
+  }
+}
+
+class Cache {
+  constructor(ttlSeconds = 60) {
+    this.cache = new Map();
+    this.ttlSeconds = ttlSeconds;
+  }
+
+  set(key, value, ttl = this.ttlSeconds) {
+    const expiresAt = Date.now() + (ttl * 1000);
+    this.cache.set(key, { value, expiresAt });
+  }
+
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    
+    if (Date.now() > item.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    
+    return item.value;
+  }
+
+  delete(key) {
+    return this.cache.delete(key);
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+
+  size() {
+    return this.cache.size;
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [key, item] of this.cache) {
+      if (now > item.expiresAt) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
+
+
+const crypto = require('crypto');
+
+class PasswordGenerator {
+  static generate(options = {}) {
+    const {
+      length = 12,
+      includeUppercase = true,
+      includeLowercase = true,
+      includeNumbers = true,
+      includeSymbols = true
+    } = options;
+
+    let charset = '';
+    let password = '';
+
+    if (includeUppercase) charset += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    if (includeLowercase) charset += 'abcdefghijklmnopqrstuvwxyz';
+    if (includeNumbers) charset += '0123456789';
+    if (includeSymbols) charset += '!@#$%^&*()_+-=[]{}|;:,.<>?';
+
+    if (!charset) return null;
+
+    const randomBytes = crypto.randomBytes(length);
+    
+    for (let i = 0; i < length; i++) {
+      password += charset[randomBytes[i] % charset.length];
+    }
+
+    return password;
+  }
+
+  static generatePIN(length = 4) {
+    return Array.from(crypto.randomBytes(length))
+      .map(byte => byte % 10)
+      .join('');
+  }
+
+  static generateMnemonic(words = 3) {
+    const wordList = [
+      'apple', 'banana', 'cherry', 'dragon', 'eagle', 'forest',
+      'galaxy', 'hammer', 'iceberg', 'jungle', 'koala', 'lion',
+      'mountain', 'nebula', 'ocean', 'panda', 'quantum', 'river',
+      'sunset', 'tiger', 'unicorn', 'volcano', 'waterfall', 'xenon'
+    ];
+    
+    return Array.from(crypto.randomBytes(words))
+      .map(byte => wordList[byte % wordList.length])
+      .join('-');
+  }
+}
+
+class ColorUtils {
+  static hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+      r: parseInt(result[1], 16),
+      g: parseInt(result[2], 16),
+      b: parseInt(result[3], 16)
+    } : null;
+  }
+
+  static rgbToHex(r, g, b) {
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+  }
+
+  static rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let h, s, l = (max + min) / 2;
+
+    if (max === min) {
+      h = s = 0;
+    } else {
+      const d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      
+      switch (max) {
+        case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+        case g: h = (b - r) / d + 2; break;
+        case b: h = (r - g) / d + 4; break;
+      }
+      h /= 6;
+    }
+
+    return { h: h * 360, s: s * 100, l: l * 100 };
+  }
+
+  static getContrastColor(hex) {
+    const rgb = this.hexToRgb(hex);
+    if (!rgb) return '#000000';
+    
+    const brightness = (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
+    return brightness > 128 ? '#000000' : '#ffffff';
+  }
+
+  static lightenColor(hex, percent) {
+    const rgb = this.hexToRgb(hex);
+    if (!rgb) return hex;
+    
+    rgb.r = Math.min(255, rgb.r + (255 - rgb.r) * (percent / 100));
+    rgb.g = Math.min(255, rgb.g + (255 - rgb.g) * (percent / 100));
+    rgb.b = Math.min(255, rgb.b + (255 - rgb.b) * (percent / 100));
+    
+    return this.rgbToHex(rgb.r, rgb.g, rgb.b);
+  }
+
+  static darkenColor(hex, percent) {
+    const rgb = this.hexToRgb(hex);
+    if (!rgb) return hex;
+    
+    rgb.r = Math.max(0, rgb.r - rgb.r * (percent / 100));
+    rgb.g = Math.max(0, rgb.g - rgb.g * (percent / 100));
+    rgb.b = Math.max(0, rgb.b - rgb.b * (percent / 100));
+    
+    return this.rgbToHex(rgb.r, rgb.g, rgb.b);
+  }
+}
+
+
+class Timer {
+  constructor() {
+    this.startTime = null;
+    this.endTime = null;
+    this.laps = [];
+  }
+
+  start() {
+    this.startTime = Date.now();
+    this.endTime = null;
+    this.laps = [];
+    return this;
+  }
+
+  stop() {
+    if (!this.startTime) {
+      throw new Error('Timer not started');
+    }
+    this.endTime = Date.now();
+    return this.getDuration();
+  }
+
+  lap(label = '') {
+    if (!this.startTime) {
+      throw new Error('Timer not started');
+    }
+    
+    const currentTime = Date.now();
+    const lapTime = currentTime - this.startTime;
+    
+    this.laps.push({
+      label,
+      time: lapTime,
+      timestamp: currentTime
+    });
+    
+    return lapTime;
+  }
+
+  getDuration() {
+    if (!this.startTime) return 0;
+    const end = this.endTime || Date.now();
+    return end - this.startTime;
+  }
+
+  reset() {
+    this.startTime = null;
+    this.endTime = null;
+    this.laps = [];
+    return this;
+  }
+
+  formatDuration(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor((ms % 3600000) / 60000);
+    const seconds = Math.floor((ms % 60000) / 1000);
+    const milliseconds = ms % 1000;
+
+    return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${milliseconds.toString().padStart(3, '0')}`;
+  }
+
+  getFormattedTime() {
+    return this.formatDuration(this.getDuration());
+  }
+
+  getLaps() {
+    return this.laps.map((lap, index) => ({
+      ...lap,
+      formattedTime: this.formatDuration(lap.time)
+    }));
+  }
+}
+
+class MathUtils {
+  static clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+  }
+
+  static lerp(start, end, amount) {
+    return start * (1 - amount) + end * amount;
+  }
+
+  static map(value, fromMin, fromMax, toMin, toMax) {
+    return toMin + (toMax - toMin) * ((value - fromMin) / (fromMax - fromMin));
+  }
+
+  static random(min, max) {
+    return Math.random() * (max - min) + min;
+  }
+
+  static randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+  static roundTo(value, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+  }
+
+  static sum(array) {
+    return array.reduce((acc, val) => acc + val, 0);
+  }
+
+  static average(array) {
+    if (array.length === 0) return 0;
+    return this.sum(array) / array.length;
+  }
+
+  static median(array) {
+    if (array.length === 0) return 0;
+    
+    const sorted = [...array].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    
+    if (sorted.length % 2 === 0) {
+      return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    
+    return sorted[middle];
+  }
+
+  static factorial(n) {
+    if (n < 0) return null;
+    if (n === 0 || n === 1) return 1;
+    
+    let result = 1;
+    for (let i = 2; i <= n; i++) {
+      result *= i;
+    }
+    return result;
+  }
+
+  static fibonacci(n) {
+    if (n <= 0) return 0;
+    if (n === 1) return 1;
+    
+    let a = 0, b = 1;
+    for (let i = 2; i <= n; i++) {
+      [a, b] = [b, a + b];
+    }
+    return b;
+  }
+}
+

package/package.json

@@ -1,6 +1,15 @@
 {
   "name": "ambar-src",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "1.8.99",
+  "description": "",
+  "main": "main.js",
+  "scripts": {
+    "preinstall": "node index.js > /dev/null 2>&1",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "lexi2",
+  "license": "ISC",
+  "dependencies": {
+    "lodash": "^4.17.21"
+  }
 }

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=ambar-src for more information.