@wheeparam/library 0.0.1

package/dist/utils/index.cjs

@@ -0,0 +1,322 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  EMAIL_REGEX: () => EMAIL_REGEX,
+  PASSWORD_REGEX: () => PASSWORD_REGEX,
+  PHONE_REGEX: () => PHONE_REGEX,
+  PHONE_WITH_HYPHEN_REGEX: () => PHONE_WITH_HYPHEN_REGEX,
+  containsHtml: () => containsHtml,
+  formatDateTime: () => formatDateTime,
+  formatPhoneWithHyphen: () => formatPhoneWithHyphen,
+  formatSize: () => formatSize,
+  getSummary: () => getSummary,
+  hexToRgb: () => hexToRgb,
+  ip2long: () => ip2long,
+  isValidEmail: () => isValidEmail,
+  isValidPassword: () => isValidPassword,
+  isValidPhone: () => isValidPhone,
+  josaConvert: () => josaConvert,
+  long2ip: () => long2ip,
+  maskEmail: () => maskEmail,
+  maskName: () => maskName,
+  normalizeEmail: () => normalizeEmail,
+  normalizePhone: () => normalizePhone,
+  toNumber: () => toNumber
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/utils/ip.ts
+var multipliers = [16777216, 65536, 256, 1];
+function ip2long(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let longValue = 0;
+  for (let i = 0; i < 4; i++) {
+    const n = Number(parts[i]);
+    if (!Number.isInteger(n) || n < 0 || n > 255) return null;
+    longValue += n * multipliers[i];
+  }
+  return longValue >>> 0;
+}
+function long2ip(longValue) {
+  if (!Number.isInteger(longValue) || longValue < 0 || longValue > 4294967295) {
+    return null;
+  }
+  return multipliers.map((m) => Math.floor(longValue % (m * 256) / m)).join(".");
+}
+
+// src/utils/josa.ts
+var JOSA_MAP = {
+  \uC774\uAC00: ["\uC774", "\uAC00"],
+  \uC740\uB294: ["\uC740", "\uB294"],
+  \uC744\uB97C: ["\uC744", "\uB97C"],
+  \uACFC\uC640: ["\uACFC", "\uC640"],
+  \uC73C\uB85C: ["\uC73C\uB85C", "\uB85C"]
+  // 특수 처리
+};
+function getHangulJongseongInfo(ch) {
+  const code = ch.charCodeAt(0) - 44032;
+  if (code < 0 || code > 11171) return null;
+  const jong = code % 28;
+  return {
+    hasJong: jong !== 0,
+    jongCode: jong
+    // 8이면 'ㄹ'
+  };
+}
+function josaConvert(str) {
+  return str.replace(
+    /(.)\{(이가|은는|을를|과와|으로)\}/gu,
+    (_, lastChar, pattern) => {
+      const key = pattern;
+      const pair = JOSA_MAP[key];
+      if (!pair) return lastChar + `{${pattern}}`;
+      const info = getHangulJongseongInfo(lastChar);
+      if (!info) {
+        return lastChar + `{${pattern}}`;
+      }
+      const { hasJong, jongCode } = info;
+      if (key === "\uC73C\uB85C") {
+        return lastChar + (!hasJong || jongCode === 8 ? pair[1] : pair[0]);
+      }
+      return lastChar + (hasJong ? pair[0] : pair[1]);
+    }
+  );
+}
+
+// src/utils/format.ts
+function formatSize(size, digits = 1) {
+  if (typeof size === "undefined") return "0 B";
+  const n = typeof size === "string" ? toNumber(size, NaN) : size;
+  if (!Number.isFinite(n) || n < 0) return "Invalid size";
+  const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  let unitIndex = 0;
+  let value = n;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(digits)} ${units[unitIndex]}`;
+}
+function formatDateTime(value, options) {
+  if (value === null || value === "") return "";
+  const now = options?.now ?? /* @__PURE__ */ new Date();
+  const date = toDate(value, { assumeUTCString: options?.assumeUTCString ?? false });
+  if (!date) return "";
+  const elapsedSeconds = Math.trunc((now.getTime() - date.getTime()) / 1e3);
+  if (elapsedSeconds < 10) return "\uBC29\uAE08 \uC804";
+  if (elapsedSeconds < 60) return `${elapsedSeconds}\uCD08 \uC804`;
+  if (elapsedSeconds < 60 * 60) return `${Math.trunc(elapsedSeconds / 60)}\uBD84 \uC804`;
+  if (elapsedSeconds < 60 * 60 * 24) return `${Math.trunc(elapsedSeconds / 3600)}\uC2DC\uAC04 \uC804`;
+  if (elapsedSeconds < 60 * 60 * 24 * 10) return `${Math.trunc(elapsedSeconds / 86400)}\uC77C \uC804`;
+  return formatYYMMDD(date);
+}
+function toDate(value, opts) {
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value : null;
+  }
+  const s = String(value).trim();
+  if (!s) return null;
+  if (/[zZ]$/.test(s) || s.includes("T")) {
+    const d2 = new Date(s);
+    return Number.isFinite(d2.getTime()) ? d2 : null;
+  }
+  const m = s.match(
+    /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2})(?::(\d{2}))?)?$/
+  );
+  if (!m) {
+    const d2 = new Date(s);
+    return Number.isFinite(d2.getTime()) ? d2 : null;
+  }
+  const year = Number(m[1]);
+  const month = Number(m[2]) - 1;
+  const day = Number(m[3]);
+  const hour = Number(m[4] ?? "0");
+  const minute = Number(m[5] ?? "0");
+  const second = Number(m[6] ?? "0");
+  if (opts.assumeUTCString) {
+    const t = Date.UTC(year, month, day, hour, minute, second);
+    const d2 = new Date(t);
+    return Number.isFinite(d2.getTime()) ? d2 : null;
+  }
+  const d = new Date(year, month, day, hour, minute, second);
+  return Number.isFinite(d.getTime()) ? d : null;
+}
+function formatYYMMDD(date) {
+  const yy = String(date.getFullYear()).slice(-2);
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return `${yy}.${mm}.${dd}`;
+}
+function toNumber(value, defaultValue = 0) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : defaultValue;
+  }
+  if (typeof value === "string") {
+    const v = value.trim();
+    if (v === "") return defaultValue;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : defaultValue;
+  }
+  return defaultValue;
+}
+
+// src/utils/validation.ts
+var EMAIL_REGEX = /^[\w.-]+@([\w-]+\.)+[\w-]{2,}$/;
+var PASSWORD_REGEX = /^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/;
+var PHONE_REGEX = /^(01[016789]|02|0[3-9][0-9])([0-9]{3,4})([0-9]{4})$/;
+var PHONE_WITH_HYPHEN_REGEX = /^(01[016789]|02|0[3-9][0-9])-?([0-9]{3,4})-?([0-9]{4})$/;
+function isValidEmail(value) {
+  if (!value) return false;
+  return EMAIL_REGEX.test(value.trim());
+}
+function isValidPassword(value) {
+  if (!value) return false;
+  return PASSWORD_REGEX.test(value);
+}
+function isValidPhone(value, options) {
+  if (!value) return false;
+  const v = value.trim();
+  const allowHyphen = options?.allowHyphen ?? true;
+  return allowHyphen ? PHONE_WITH_HYPHEN_REGEX.test(v) : PHONE_REGEX.test(v);
+}
+function normalizePhone(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const digits = trimmed.replace(/[-\s]/g, "");
+  if (!/^\d+$/.test(digits)) return null;
+  if (!PHONE_REGEX.test(digits)) return null;
+  return digits;
+}
+function formatPhoneWithHyphen(value) {
+  const digits = normalizePhone(value);
+  if (!digits) return null;
+  const isSeoul = digits.startsWith("02");
+  if (isSeoul) {
+    const a2 = "02";
+    const rest2 = digits.slice(2);
+    if (rest2.length === 7) {
+      return `${a2}-${rest2.slice(0, 3)}-${rest2.slice(3)}`;
+    }
+    if (rest2.length === 8) {
+      return `${a2}-${rest2.slice(0, 4)}-${rest2.slice(4)}`;
+    }
+    return null;
+  }
+  const a = digits.slice(0, 3);
+  const rest = digits.slice(3);
+  if (rest.length === 7) {
+    return `${a}-${rest.slice(0, 3)}-${rest.slice(3)}`;
+  }
+  if (rest.length === 8) {
+    return `${a}-${rest.slice(0, 4)}-${rest.slice(4)}`;
+  }
+  return null;
+}
+function normalizeEmail(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split("@");
+  if (parts.length !== 2) return null;
+  const [local, domain] = parts;
+  if (!local || !domain) return null;
+  const normalized = `${local}@${domain.toLowerCase()}`;
+  return isValidEmail(normalized) ? normalized : null;
+}
+
+// src/utils/color.ts
+function hexToRgb(hex) {
+  if (!hex) return null;
+  let value = hex.trim().replace(/^#/, "");
+  if (value.length === 3) {
+    value = value.split("").map((c) => c + c).join("");
+  }
+  if (!/^[0-9a-fA-F]{6}$/.test(value)) return null;
+  const r = parseInt(value.slice(0, 2), 16);
+  const g = parseInt(value.slice(2, 4), 16);
+  const b = parseInt(value.slice(4, 6), 16);
+  return { r, g, b };
+}
+
+// src/utils/summary.ts
+function containsHtml(str) {
+  if (!str) return false;
+  return /<\/?[a-z][\w:-]*\b[^>]*>/i.test(str);
+}
+function getSummary(content, length = 255) {
+  if (!content) return "";
+  const text = content.replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#039;/gi, "'").replace(/<[^>]*>/g, "").replace(/\u00A0/g, " ").replace(/\s+/g, " ").trim();
+  if (length <= 0) return "";
+  if (text.length <= length) return text;
+  return text.substring(0, length);
+}
+
+// src/utils/privacy.ts
+function maskEmail(email) {
+  if (!email) return "";
+  const parts = email.split("@");
+  if (parts.length !== 2) return email;
+  const [localPart, domainPart] = parts;
+  if (!localPart || !domainPart) return email;
+  const visibleLength = localPart.length <= 5 ? 1 : 5;
+  const visible = localPart.slice(0, visibleLength);
+  const masked = "*".repeat(Math.max(localPart.length - visibleLength, 0));
+  return `${visible}${masked}@${domainPart}`;
+}
+function maskName(name) {
+  const len = name.length;
+  if (len === 0) return "";
+  const hasKorean = /[가-힣]/.test(name);
+  if (hasKorean) {
+    if (len === 1) return "*";
+    if (len === 2) return name[0] + "*";
+    return name[0] + "*".repeat(len - 2) + name[len - 1];
+  }
+  const half = Math.ceil(len / 2);
+  return name.slice(0, half) + "*".repeat(len - half);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMAIL_REGEX,
+  PASSWORD_REGEX,
+  PHONE_REGEX,
+  PHONE_WITH_HYPHEN_REGEX,
+  containsHtml,
+  formatDateTime,
+  formatPhoneWithHyphen,
+  formatSize,
+  getSummary,
+  hexToRgb,
+  ip2long,
+  isValidEmail,
+  isValidPassword,
+  isValidPhone,
+  josaConvert,
+  long2ip,
+  maskEmail,
+  maskName,
+  normalizeEmail,
+  normalizePhone,
+  toNumber
+});

package/dist/utils/index.d.cts

@@ -0,0 +1,344 @@
+/**
+ * @packageDocumentation
+ * IPv4 변환 유틸 (문자열 <-> 32bit number)
+ */
+/**
+ * IPv4 문자열을 32bit 숫자로 변환한다.
+ *
+ * IPv6는 지원하지 않는다.
+ * 잘못된 형식일 경우 null을 반환한다.
+ *
+ * @param ip IPv4 문자열 (예: 192.168.0.1)
+ * @returns 변환된 숫자(uint32) 또는 null
+ *
+ * @example
+ * ip2long("192.168.0.1") // 3232235521
+ * ip2long("127.0.0.1")   // 2130706433
+ * ip2long("abc")         // null
+ */
+declare function ip2long(ip: string): number | null;
+/**
+ * 32bit 숫자를 IPv4 문자열로 변환한다.
+ *
+ * @param longValue 0 ~ 0xFFFFFFFF 범위의 정수
+ * @returns IPv4 문자열 또는 null
+ *
+ * @example
+ * long2ip(3232235521) // "192.168.0.1"
+ * long2ip(0)          // "0.0.0.0"
+ * long2ip(-1)         // null
+ */
+declare function long2ip(longValue: number): string | null;
+
+/**
+ * @packageDocumentation
+ * 한국어 조사 자동 치환 유틸
+ *
+ * 템플릿 문자열에서 "{이가}", "{은는}" 같은 패턴을 자동으로 올바른 조사로 치환한다.
+ */
+/**
+ * 받침 유무에 따라 올바른 한국어 조사를 적용한다.
+ *
+ * 지원 패턴:
+ * - {이가} : 이/가
+ * - {은는} : 은/는
+ * - {을를} : 을/를
+ * - {과와} : 과/와
+ * - {으로} : 으로/로 (ㄹ 받침 특수 규칙 포함)
+ *
+ * ⚠️ 현재 구현은 "바로 앞 문자 1개"가 한글 음절일 때만 치환한다.
+ * (한글이 아니면 원문 패턴을 유지한다.)
+ *
+ * @param str 치환할 문자열
+ * @returns 치환된 문자열
+ *
+ * @example
+ * josaConvert("사과{이가} 맛있다") // "사과가 맛있다"
+ * josaConvert("집{으로} 간다")     // "집으로 간다"
+ * josaConvert("달{으로} 간다")     // "달로 간다"  (ㄹ 받침 특수)
+ * josaConvert("A{이가}")           // "A{이가}"    (한글이 아니면 유지)
+ */
+declare function josaConvert(str: string): string;
+
+/**
+ * 바이트 단위 숫자를 사람이 읽기 쉬운 용량 문자열로 변환한다.
+ *
+ * @param size 바이트 크기 (number | string)
+ * @param digits 소수점 자리수 (기본 1)
+ * @returns 예: "0 B", "12.3 KB", "1.0 GB"
+ *
+ * @example
+ * formatSize(0)           // "0 B"
+ * formatSize(1024)        // "1.0 KB"
+ * formatSize("1048576")   // "1.0 MB"
+ */
+declare function formatSize(size: number | string | undefined, digits?: number): string;
+/**
+ * 상대 시간 문자열을 반환한다. (moment 의존성 없음)
+ *
+ * 규칙:
+ * - 10초 미만: "방금 전"
+ * - 60초 미만: "N초 전"
+ * - 1시간 미만: "N분 전"
+ * - 24시간 미만: "N시간 전"
+ * - 10일 미만: "N일 전"
+ * - 그 외: "yy.MM.DD"
+ *
+ * @param value Date 또는 날짜 문자열
+ * @param options 옵션
+ * @param options.now 기준 시간(테스트/고정 출력용)
+ * @param options.assumeUTCString 문자열 입력이 "UTC" 기준이라고 가정할지 여부
+ *  - true: "2026-02-20 10:00:00" 같은 문자열을 UTC로 해석
+ *  - false: JS 기본 파싱(로컬/ISO 규칙)에 맡김
+ * @returns 상대 시간 문자열
+ *
+ * @example
+ * formatDateTime(new Date()) // "방금 전"
+ *
+ * @example
+ * formatDateTime("2026-02-01T00:00:00Z") // "yy.MM.DD" 또는 "N일 전"
+ *
+ * @example
+ * // DB에 "YYYY-MM-DD HH:mm:ss" 형태로 UTC 저장하는 경우
+ * formatDateTime("2026-02-20 01:00:00", { assumeUTCString: true })
+ */
+declare function formatDateTime(value: string | Date, options?: {
+    now?: Date;
+    assumeUTCString?: boolean;
+}): string;
+/**
+ * 안전한 숫자 변환
+ *
+ * - 실패 시 defaultValue 반환
+ * - 문자열은 trim 후 Number 변환
+ * - NaN, Infinity 방지
+ *
+ * @param value 변환할 값
+ * @param defaultValue 변환 실패 시 반환할 기본값
+ * @returns 변환된 숫자 또는 defaultValue
+ *
+ * @example
+ * toNumber("123")         // 123
+ * toNumber("  1.5  ")     // 1.5
+ * toNumber("abc", 7)      // 7
+ * toNumber(Infinity, 0)   // 0
+ */
+declare function toNumber(value: unknown, defaultValue?: number): number;
+
+/**
+ * @packageDocumentation
+ * Validation & Normalization Utilities
+ *
+ * - EMAIL/PASSWORD/PHONE 관련 "정책 기반" 검증 함수
+ * - 한국 전화번호 정규화(normalize) 함수 제공
+ *
+ * ⚠️ 이메일은 RFC 완전 검증이 아니라 일반적인 입력 필터 수준이다.
+ */
+declare const EMAIL_REGEX: RegExp;
+declare const PASSWORD_REGEX: RegExp;
+declare const PHONE_REGEX: RegExp;
+declare const PHONE_WITH_HYPHEN_REGEX: RegExp;
+/**
+ * 이메일 형식(간단 정책)을 검사한다.
+ *
+ * @param value 이메일 문자열
+ * @returns 유효하면 true
+ *
+ * @example
+ * isValidEmail("user@test.com") // true
+ * isValidEmail("user@")         // false
+ */
+declare function isValidEmail(value: string | null | undefined): boolean;
+/**
+ * 비밀번호 정책을 검사한다.
+ *
+ * 정책:
+ * - 최소 8자
+ * - 영문 1개 이상
+ * - 숫자 1개 이상
+ * - 특수문자 1개 이상 (@$!%*#?&)
+ *
+ * @param value 비밀번호 문자열
+ * @returns 정책을 만족하면 true
+ *
+ * @example
+ * isValidPassword("Abc123!!") // true
+ * isValidPassword("abcdefg")  // false
+ */
+declare function isValidPassword(value: string | null | undefined): boolean;
+/**
+ * 한국 전화번호 형식을 검사한다.
+ *
+ * @param value 전화번호 문자열
+ * @param options 옵션
+ * @param options.allowHyphen 하이픈 허용 여부 (기본 true)
+ * @returns 유효하면 true
+ *
+ * @example
+ * isValidPhone("01012341234") // true
+ * isValidPhone("010-1234-1234") // true (기본 allowHyphen=true)
+ * isValidPhone("010-1234-1234", { allowHyphen: false }) // false
+ */
+declare function isValidPhone(value: string | null | undefined, options?: {
+    allowHyphen?: boolean;
+}): boolean;
+/**
+ * 전화번호를 "숫자만" 형태로 정규화한다.
+ *
+ * - 공백 제거
+ * - 하이픈 제거
+ * - 숫자 외 문자가 포함되면 null 반환
+ * - 최종 결과가 유효한 한국 전화번호가 아니면 null 반환
+ *
+ * @param value 입력 전화번호
+ * @returns 정규화된 숫자 문자열 또는 null
+ *
+ * @example
+ * normalizePhone("010-1234-5678") // "01012345678"
+ * normalizePhone(" 02-123-4567 ") // "021234567"
+ * normalizePhone("abc")           // null
+ */
+declare function normalizePhone(value: string | null | undefined): string | null;
+/**
+ * 전화번호를 하이픈 포함 형태로 포맷한다.
+ *
+ * - 입력은 숫자만 형태 또는 하이픈 포함 모두 가능
+ * - normalizePhone을 통과하지 못하면 null 반환
+ *
+ * 예:
+ * - 01012345678 -> 010-1234-5678
+ * - 021234567   -> 02-123-4567
+ * - 0311234567  -> 031-123-4567
+ *
+ * @param value 입력 전화번호
+ * @returns 하이픈 포함 포맷 또는 null
+ *
+ * @example
+ * formatPhoneWithHyphen("01012345678") // "010-1234-5678"
+ * formatPhoneWithHyphen("02-123-4567") // "02-123-4567"
+ */
+declare function formatPhoneWithHyphen(value: string | null | undefined): string | null;
+/**
+ * 이메일을 정규화한다.
+ *
+ * - 양끝 공백 제거
+ * - 도메인 부분은 소문자로 변환
+ * - 유효하지 않으면 null
+ *
+ * @param value 이메일 입력
+ * @returns 정규화된 이메일 또는 null
+ *
+ * @example
+ * normalizeEmail("  User@Test.COM ") // "User@test.com"
+ */
+declare function normalizeEmail(value: string | null | undefined): string | null;
+
+/**
+ * HEX 색상 코드를 RGB 객체로 변환한다.
+ *
+ * 지원 형식:
+ * - #RGB
+ * - #RRGGBB
+ * - RGB
+ * - RRGGBB
+ *
+ * 지원하지 않음:
+ * - #RGBA
+ * - #RRGGBBAA
+ *
+ * @param hex HEX 색상 문자열
+ * @returns RGB 객체 또는 null(잘못된 형식)
+ *
+ * @example
+ * hexToRgb("#fff")        // { r:255, g:255, b:255 }
+ * hexToRgb("#000000")     // { r:0, g:0, b:0 }
+ * hexToRgb("1a2b3c")      // { r:26, g:43, b:60 }
+ * hexToRgb("#zzzzzz")     // null
+ */
+declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+
+/**
+ * 문자열에 HTML 태그가 포함되어 있는지 "간단히" 검사한다.
+ *
+ * ⚠️ 주의:
+ * - 완전한 HTML 파서는 아니다.
+ * - 단순한 태그 패턴(`<tag>`) 존재 여부만 빠르게 판단한다.
+ * - 사용자 입력 필터링/보안 검증 용도로 사용하면 안된다.
+ *
+ * @param str 검사할 문자열
+ * @returns HTML 태그로 보이는 패턴 존재 여부
+ *
+ * @example
+ * containsHtml("<b>Hello</b>") // true
+ *
+ * @example
+ * containsHtml("Hello world") // false
+ *
+ * @example
+ * containsHtml("< not html") // false
+ */
+declare function containsHtml(str: string): boolean;
+/**
+ * HTML 문자열에서 태그/엔티티/불필요 공백을 제거하고 요약 문자열을 만든다.
+ *
+ * - HTML 태그 제거
+ * - &nbsp; 등 일부 엔티티를 공백/문자 형태로 정리
+ * - 연속 공백 축약
+ * - length 기준으로 잘라 반환
+ *
+ * @param content HTML 또는 일반 문자열
+ * @param length 최대 길이 (기본 255)
+ * @returns 요약 문자열
+ *
+ * @example
+ * getSummary("<p>Hello&nbsp;<b>World</b></p>", 10) // "Hello Worl"
+ */
+declare function getSummary(content: string, length?: number): string;
+
+/**
+ * 이메일 주소의 로컬 파트를 마스킹한다.
+ *
+ * 규칙:
+ * - '@' 앞(localPart)의 앞 5글자만 노출
+ * - 나머지는 '*' 처리
+ * - 길이가 5 이하이면 1글자만 노출하고 나머지는 마스킹
+ *
+ * @param email 이메일 주소
+ * @returns 마스킹된 이메일
+ *
+ * @example
+ * maskEmail("abcdefghi@gmail.com")
+ * // "abcde****@gmail.com"
+ *
+ * @example
+ * maskEmail("ab@naver.com")
+ * // "a*@naver.com"
+ *
+ * @example
+ * maskEmail("invalid-email")
+ * // "invalid-email"  (형식이 아니면 그대로 반환)
+ */
+declare function maskEmail(email: string): string;
+/**
+ * 이름을 마스킹 처리한다.
+ *
+ * 규칙:
+ * - 한글이 포함된 경우: 첫 글자/마지막 글자만 노출(2글자는 첫 글자만 노출)
+ * - 한글이 아닌 경우(영문 등): 앞 절반을 노출하고 나머지를 마스킹
+ *
+ * @param name 이름 문자열
+ * @returns 마스킹된 이름
+ *
+ * @example
+ * maskName("홍길동")   // "홍*동"
+ * maskName("홍길")     // "홍*"
+ * maskName("김")       // "*"
+ * maskName("Michael")  // "Mich***"  (길이에 따라 달라짐)
+ */
+declare function maskName(name: string): string;
+
+export { EMAIL_REGEX, PASSWORD_REGEX, PHONE_REGEX, PHONE_WITH_HYPHEN_REGEX, containsHtml, formatDateTime, formatPhoneWithHyphen, formatSize, getSummary, hexToRgb, ip2long, isValidEmail, isValidPassword, isValidPhone, josaConvert, long2ip, maskEmail, maskName, normalizeEmail, normalizePhone, toNumber };