@no-k/hermes 0.1.0

package/templates/http/status/status.ts

@@ -0,0 +1,191 @@
+export const HTTP_STATUS = {
+  _100_CONTINUE: 100,
+  _101_SWITCHING_PROTOCOLS: 101,
+  _102_PROCESSING: 102,
+  _103_EARLY_HINTS: 103,
+  _200_OK: 200,
+  _201_CREATED: 201,
+  _202_ACCEPTED: 202,
+  _203_NON_AUTHORITATIVE_INFORMATION: 203,
+  _204_NO_CONTENT: 204,
+  _205_RESET_CONTENT: 205,
+  _206_PARTIAL_CONTENT: 206,
+  _207_MULTI_STATUS: 207,
+  _208_ALREADY_REPORTED: 208,
+  _226_IM_USED: 226,
+  _300_MULTIPLE_CHOICES: 300,
+  _301_MOVED_PERMANENTLY: 301,
+  _302_FOUND: 302,
+  _303_SEE_OTHER: 303,
+  _304_NOT_MODIFIED: 304,
+  _305_USE_PROXY: 305,
+  _307_TEMPORARY_REDIRECT: 307,
+  _308_PERMANENT_REDIRECT: 308,
+  _400_BAD_REQUEST: 400,
+  _401_UNAUTHORIZED: 401,
+  _402_PAYMENT_REQUIRED: 402,
+  _403_FORBIDDEN: 403,
+  _404_NOT_FOUND: 404,
+  _405_METHOD_NOT_ALLOWED: 405,
+  _406_NOT_ACCEPTABLE: 406,
+  _407_PROXY_AUTHENTICATION_REQUIRED: 407,
+  _408_REQUEST_TIMEOUT: 408,
+  _409_CONFLICT: 409,
+  _410_GONE: 410,
+  _411_LENGTH_REQUIRED: 411,
+  _412_PRECONDITION_FAILED: 412,
+  _413_PAYLOAD_TOO_LARGE: 413,
+  _414_URI_TOO_LONG: 414,
+  _415_UNSUPPORTED_MEDIA_TYPE: 415,
+  _416_RANGE_NOT_SATISFIABLE: 416,
+  _417_EXPECTATION_FAILED: 417,
+  _418_IM_A_TEAPOT: 418,
+  _421_MISDIRECTED_REQUEST: 421,
+  _422_UNPROCESSABLE_CONTENT: 422,
+  _423_LOCKED: 423,
+  _424_FAILED_DEPENDENCY: 424,
+  _425_TOO_EARLY: 425,
+  _426_UPGRADE_REQUIRED: 426,
+  _428_PRECONDITION_REQUIRED: 428,
+  _429_TOO_MANY_REQUESTS: 429,
+  _431_REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  _451_UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  _500_INTERNAL_SERVER_ERROR: 500,
+  _501_NOT_IMPLEMENTED: 501,
+  _502_BAD_GATEWAY: 502,
+  _503_SERVICE_UNAVAILABLE: 503,
+  _504_GATEWAY_TIMEOUT: 504,
+  _505_HTTP_VERSION_NOT_SUPPORTED: 505,
+  _506_VARIANT_ALSO_NEGOTIATES: 506,
+  _507_INSUFFICIENT_STORAGE: 507,
+  _508_LOOP_DETECTED: 508,
+  _510_NOT_EXTENDED: 510,
+  _511_NETWORK_AUTHENTICATION_REQUIRED: 511,
+} as const;
+
+export type KnownHttpStatusCode = (typeof HTTP_STATUS)[keyof typeof HTTP_STATUS];
+
+export type HttpStatusGroup = "informational" | "success" | "redirection" | "client-error" | "server-error";
+
+export const HTTP_STATUS_TEXT: Record<KnownHttpStatusCode, string> = {
+  [HTTP_STATUS._100_CONTINUE]: "Continue",
+  [HTTP_STATUS._101_SWITCHING_PROTOCOLS]: "Switching Protocols",
+  [HTTP_STATUS._102_PROCESSING]: "Processing",
+  [HTTP_STATUS._103_EARLY_HINTS]: "Early Hints",
+  [HTTP_STATUS._200_OK]: "OK",
+  [HTTP_STATUS._201_CREATED]: "Created",
+  [HTTP_STATUS._202_ACCEPTED]: "Accepted",
+  [HTTP_STATUS._203_NON_AUTHORITATIVE_INFORMATION]: "Non-Authoritative Information",
+  [HTTP_STATUS._204_NO_CONTENT]: "No Content",
+  [HTTP_STATUS._205_RESET_CONTENT]: "Reset Content",
+  [HTTP_STATUS._206_PARTIAL_CONTENT]: "Partial Content",
+  [HTTP_STATUS._207_MULTI_STATUS]: "Multi-Status",
+  [HTTP_STATUS._208_ALREADY_REPORTED]: "Already Reported",
+  [HTTP_STATUS._226_IM_USED]: "IM Used",
+  [HTTP_STATUS._300_MULTIPLE_CHOICES]: "Multiple Choices",
+  [HTTP_STATUS._301_MOVED_PERMANENTLY]: "Moved Permanently",
+  [HTTP_STATUS._302_FOUND]: "Found",
+  [HTTP_STATUS._303_SEE_OTHER]: "See Other",
+  [HTTP_STATUS._304_NOT_MODIFIED]: "Not Modified",
+  [HTTP_STATUS._305_USE_PROXY]: "Use Proxy",
+  [HTTP_STATUS._307_TEMPORARY_REDIRECT]: "Temporary Redirect",
+  [HTTP_STATUS._308_PERMANENT_REDIRECT]: "Permanent Redirect",
+  [HTTP_STATUS._400_BAD_REQUEST]: "Bad Request",
+  [HTTP_STATUS._401_UNAUTHORIZED]: "Unauthorized",
+  [HTTP_STATUS._402_PAYMENT_REQUIRED]: "Payment Required",
+  [HTTP_STATUS._403_FORBIDDEN]: "Forbidden",
+  [HTTP_STATUS._404_NOT_FOUND]: "Not Found",
+  [HTTP_STATUS._405_METHOD_NOT_ALLOWED]: "Method Not Allowed",
+  [HTTP_STATUS._406_NOT_ACCEPTABLE]: "Not Acceptable",
+  [HTTP_STATUS._407_PROXY_AUTHENTICATION_REQUIRED]: "Proxy Authentication Required",
+  [HTTP_STATUS._408_REQUEST_TIMEOUT]: "Request Timeout",
+  [HTTP_STATUS._409_CONFLICT]: "Conflict",
+  [HTTP_STATUS._410_GONE]: "Gone",
+  [HTTP_STATUS._411_LENGTH_REQUIRED]: "Length Required",
+  [HTTP_STATUS._412_PRECONDITION_FAILED]: "Precondition Failed",
+  [HTTP_STATUS._413_PAYLOAD_TOO_LARGE]: "Payload Too Large",
+  [HTTP_STATUS._414_URI_TOO_LONG]: "URI Too Long",
+  [HTTP_STATUS._415_UNSUPPORTED_MEDIA_TYPE]: "Unsupported Media Type",
+  [HTTP_STATUS._416_RANGE_NOT_SATISFIABLE]: "Range Not Satisfiable",
+  [HTTP_STATUS._417_EXPECTATION_FAILED]: "Expectation Failed",
+  [HTTP_STATUS._418_IM_A_TEAPOT]: "I'm a Teapot",
+  [HTTP_STATUS._421_MISDIRECTED_REQUEST]: "Misdirected Request",
+  [HTTP_STATUS._422_UNPROCESSABLE_CONTENT]: "Unprocessable Content",
+  [HTTP_STATUS._423_LOCKED]: "Locked",
+  [HTTP_STATUS._424_FAILED_DEPENDENCY]: "Failed Dependency",
+  [HTTP_STATUS._425_TOO_EARLY]: "Too Early",
+  [HTTP_STATUS._426_UPGRADE_REQUIRED]: "Upgrade Required",
+  [HTTP_STATUS._428_PRECONDITION_REQUIRED]: "Precondition Required",
+  [HTTP_STATUS._429_TOO_MANY_REQUESTS]: "Too Many Requests",
+  [HTTP_STATUS._431_REQUEST_HEADER_FIELDS_TOO_LARGE]: "Request Header Fields Too Large",
+  [HTTP_STATUS._451_UNAVAILABLE_FOR_LEGAL_REASONS]: "Unavailable For Legal Reasons",
+  [HTTP_STATUS._500_INTERNAL_SERVER_ERROR]: "Internal Server Error",
+  [HTTP_STATUS._501_NOT_IMPLEMENTED]: "Not Implemented",
+  [HTTP_STATUS._502_BAD_GATEWAY]: "Bad Gateway",
+  [HTTP_STATUS._503_SERVICE_UNAVAILABLE]: "Service Unavailable",
+  [HTTP_STATUS._504_GATEWAY_TIMEOUT]: "Gateway Timeout",
+  [HTTP_STATUS._505_HTTP_VERSION_NOT_SUPPORTED]: "HTTP Version Not Supported",
+  [HTTP_STATUS._506_VARIANT_ALSO_NEGOTIATES]: "Variant Also Negotiates",
+  [HTTP_STATUS._507_INSUFFICIENT_STORAGE]: "Insufficient Storage",
+  [HTTP_STATUS._508_LOOP_DETECTED]: "Loop Detected",
+  [HTTP_STATUS._510_NOT_EXTENDED]: "Not Extended",
+  [HTTP_STATUS._511_NETWORK_AUTHENTICATION_REQUIRED]: "Network Authentication Required",
+};
+
+const KNOWN_HTTP_STATUS_CODE_SET = new Set<number>(Object.values(HTTP_STATUS));
+
+const isStatusInRange = (statusCode: number, min: number, max: number): boolean => {
+  return Number.isInteger(statusCode) && statusCode >= min && statusCode <= max;
+};
+
+export const isHttpStatusCode = (statusCode: number): boolean => {
+  return isStatusInRange(statusCode, 100, 599);
+};
+
+export const isKnownHttpStatusCode = (statusCode: number): statusCode is KnownHttpStatusCode => {
+  return KNOWN_HTTP_STATUS_CODE_SET.has(statusCode);
+};
+
+export const getHttpStatusGroup = (statusCode: number): HttpStatusGroup | undefined => {
+  if (isStatusInRange(statusCode, 100, 199)) {
+    return "informational";
+  }
+
+  if (isStatusInRange(statusCode, 200, 299)) {
+    return "success";
+  }
+
+  if (isStatusInRange(statusCode, 300, 399)) {
+    return "redirection";
+  }
+
+  if (isStatusInRange(statusCode, 400, 499)) {
+    return "client-error";
+  }
+
+  if (isStatusInRange(statusCode, 500, 599)) {
+    return "server-error";
+  }
+
+  return undefined;
+};
+
+export const isInformationalStatus = (statusCode: number): boolean => {
+  return getHttpStatusGroup(statusCode) === "informational";
+};
+
+export const isSuccessStatus = (statusCode: number): boolean => {
+  return getHttpStatusGroup(statusCode) === "success";
+};
+
+export const isRedirectionStatus = (statusCode: number): boolean => {
+  return getHttpStatusGroup(statusCode) === "redirection";
+};
+
+export const isClientErrorStatus = (statusCode: number): boolean => {
+  return getHttpStatusGroup(statusCode) === "client-error";
+};
+
+export const isServerErrorStatus = (statusCode: number): boolean => {
+  return getHttpStatusGroup(statusCode) === "server-error";
+};

package/templates/number/clamp/clamp.ts

@@ -0,0 +1,11 @@
+export const clamp = (value: number, min: number, max: number): number => {
+  if (value < min) {
+    return min;
+  }
+
+  if (value > max) {
+    return max;
+  }
+
+  return value;
+};

package/templates/number/clamp/index.ts

@@ -0,0 +1 @@
+export * from "./clamp";

package/templates/number/factorial/factorial.ts

@@ -0,0 +1,15 @@
+// 계승(factorial). n! = 1 * 2 * ... * n.
+// 음수는 정의되지 않으므로 RangeError를 던진다. 0! = 1 (빈 곱의 항등원).
+// 반복문으로 구현해 깊은 재귀의 스택 비용을 피한다.
+export const factorial = (n: number): number => {
+  if (n < 0) {
+    throw new RangeError(`factorial is not defined for negative numbers: ${n}`);
+  }
+
+  let result = 1;
+  for (let i = 2; i <= n; i += 1) {
+    result *= i;
+  }
+
+  return result;
+};

package/templates/number/factorial/index.ts

@@ -0,0 +1 @@
+export * from "./factorial";

package/templates/number/format-thousands/format-thousands.ts

@@ -0,0 +1,24 @@
+// 정수부에 천 단위 콤마를 넣는다. 1234567 -> "1,234,567".
+// 콤마는 정수부에만 붙이고 소수부와 음수 부호는 그대로 보존한다
+// (-1234.5 -> "-1,234.5").
+//
+// Intl.NumberFormat 대신 직접 구현한 이유: Intl은 로케일/환경에 따라 그룹
+// 구분자가 달라지고(공백·점 등) maximumFractionDigits 기본값이 소수부를 잘라
+// 결과가 미묘하게 흔들린다. 여기선 콤마 고정 + 소수부 완전 보존이 계약이라
+// 문자열을 직접 다룬다.
+//
+// 정규식 `\B(?=(\d{3})+(?!\d))`는 "오른쪽으로 3자리씩 묶었을 때 그 경계이면서
+// 단어 경계가 아닌 위치" 앞에 콤마를 끼운다. 정수부에만 적용해 소수점 이후로는
+// 번지지 않게 한다.
+export const formatThousands = (value: number): string => {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+
+  const sign = value < 0 ? "-" : "";
+  // 부호는 따로 떼어 두고 절댓값 문자열만 가공한다.
+  const [integer, fraction] = Math.abs(value).toString().split(".");
+  const grouped = integer.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+
+  return `${sign}${grouped}${fraction === undefined ? "" : `.${fraction}`}`;
+};

package/templates/number/format-thousands/index.ts

@@ -0,0 +1 @@
+export * from "./format-thousands";

package/templates/number/gcd/gcd.ts

@@ -0,0 +1,13 @@
+// 최대공약수(GCD). 유클리드 호제법으로 구한다.
+// 부호는 결과에 의미가 없으므로 입력을 절댓값으로 정규화한다 (gcd(-12, 8) === gcd(12, 8)).
+// 한쪽이 0이면 다른 쪽의 절댓값이 곧 GCD다 (gcd(0, n) === |n|, gcd(0, 0) === 0).
+export const gcd = (a: number, b: number): number => {
+  let x = Math.abs(a);
+  let y = Math.abs(b);
+
+  while (y !== 0) {
+    [x, y] = [y, x % y];
+  }
+
+  return x;
+};

package/templates/number/gcd/index.ts

@@ -0,0 +1 @@
+export * from "./gcd";

package/templates/number/in-range/in-range.ts

@@ -0,0 +1,3 @@
+export const inRange = (value: number, min: number, max: number): boolean => {
+  return value >= min && value < max;
+};

package/templates/number/in-range/index.ts

@@ -0,0 +1 @@
+export * from "./in-range";

package/templates/number/is-even/index.ts

@@ -0,0 +1 @@
+export * from "./is-even";

package/templates/number/is-even/is-even.ts

@@ -0,0 +1,5 @@
+// 짝수 여부. 2로 나눈 나머지가 0이면 짝수다.
+// 음수와 0도 동일하게 판정된다 (-4, 0 모두 짝수). `% 2`는 음수에서도 0을 그대로 돌려준다.
+export const isEven = (value: number): boolean => {
+  return value % 2 === 0;
+};

package/templates/number/is-odd/index.ts

@@ -0,0 +1 @@
+export * from "./is-odd";

package/templates/number/is-odd/is-odd.ts

@@ -0,0 +1,7 @@
+import { isEven } from "../is-even/index";
+
+// 홀수 여부. 짝수가 아니면 홀수다. isEven을 부정해 짝/홀 판정 규칙을 한 곳에 둔다.
+// 음수도 동일하게 판정된다 (-3은 홀수).
+export const isOdd = (value: number): boolean => {
+  return !isEven(value);
+};

package/templates/number/lcm/index.ts

@@ -0,0 +1 @@
+export * from "./lcm";

package/templates/number/lcm/lcm.ts

@@ -0,0 +1,12 @@
+import { gcd } from "../gcd/index";
+
+// 최소공배수(LCM). lcm(a, b) = |a * b| / gcd(a, b) 로 구한다.
+// 한쪽이 0이면 공배수가 0뿐이므로 0을 반환한다 (gcd가 0이 되어 나눗셈을 피하는 의미도 있다).
+// 부호는 GCD와 마찬가지로 결과에 의미가 없어 절댓값으로 정규화한다.
+export const lcm = (a: number, b: number): number => {
+  if (a === 0 || b === 0) {
+    return 0;
+  }
+
+  return Math.abs(a / gcd(a, b)) * Math.abs(b);
+};

package/templates/number/lerp/index.ts

@@ -0,0 +1 @@
+export * from "./lerp";

package/templates/number/lerp/lerp.ts

@@ -0,0 +1,3 @@
+export const lerp = (start: number, end: number, t: number): number => {
+  return start + (end - start) * t;
+};

package/templates/number/percentage/index.ts

@@ -0,0 +1 @@
+export * from "./percentage";

package/templates/number/percentage/percentage.ts

@@ -0,0 +1,7 @@
+export const percentage = (value: number, total: number): number => {
+  if (total === 0) {
+    return 0;
+  }
+
+  return (value / total) * 100;
+};

package/templates/number/random/index.ts

@@ -0,0 +1 @@
+export * from "./random";

package/templates/number/random/random.ts

@@ -0,0 +1,9 @@
+// [min, max) 구간의 실수 난수를 런타임 난수로 뽑는다. min은 포함, max는 제외다.
+//
+// 매번 새 값을 계산해 반환하며 인자는 변형하지 않는다. 난수원은 Math.random이라
+// 암호학적으로 안전하지 않다 (가벼운 무작위 실수 생성 용도).
+// min === max면 구간이 비어 있어 항상 min을 반환한다. min > max도 막지 않으므로
+// 호출 측에서 min <= max를 보장한다.
+export const random = (min: number, max: number): number => {
+  return min + Math.random() * (max - min);
+};

package/templates/number/random-int/index.ts

@@ -0,0 +1 @@
+export * from "./random-int";

package/templates/number/random-int/random-int.ts

@@ -0,0 +1,9 @@
+// [min, max] 구간의 정수 난수를 런타임 난수로 뽑는다. 양끝(min, max)을 모두 포함한다.
+//
+// min, max는 정수라고 가정한다. 구간 크기는 max - min + 1이라 max 쪽도 동일 확률로 뽑힌다.
+// 매번 새 값을 계산해 반환하며 인자는 변형하지 않는다. 난수원은 Math.random이라
+// 암호학적으로 안전하지 않다 (주사위/인덱스 같은 가벼운 무작위 정수 생성 용도).
+// min === max면 항상 그 값을 반환한다. min <= max는 호출 측에서 보장한다.
+export const randomInt = (min: number, max: number): number => {
+  return min + Math.floor(Math.random() * (max - min + 1));
+};

package/templates/number/round/index.ts

@@ -0,0 +1 @@
+export * from "./round";

package/templates/number/round/round.ts

@@ -0,0 +1,22 @@
+// value를 digits 자리수로 반올림한다. digits 기본값 0은 정수 반올림.
+// Math.round(value * 10**digits) / 10**digits 의 단순식은 부동소수점 오차로
+// 흔히 어긋난다 (예: 1.005 * 100 === 100.49999999999999 -> 100). 그래서
+// 지수 표기(toExponential)로 가수의 소수점만 옮겨 반올림한 뒤 되돌린다.
+// 이렇게 하면 곱셈으로 생기는 표현 오차를 거치지 않아 1.005 같은 경계값이
+// 기대대로 반올림된다.
+// digits는 정수로 강제하고, 음수 digits(10의 자리 등 정수부 반올림)도 지원한다.
+export const round = (value: number, digits = 0): number => {
+  if (!Number.isFinite(value)) {
+    return value;
+  }
+
+  const shift = Math.trunc(digits);
+
+  // 가수와 지수를 분리해 지수에 shift를 더한 뒤 그 자리에서 반올림하고,
+  // 다시 같은 크기만큼 지수를 빼서 원래 스케일로 되돌린다.
+  const [mantissa, exponent] = value.toExponential().split("e");
+  const rounded = Math.round(Number(`${mantissa}e${Number(exponent) + shift}`));
+  const [resultMantissa, resultExponent] = rounded.toExponential().split("e");
+
+  return Number(`${resultMantissa}e${Number(resultExponent) - shift}`);
+};

package/templates/number/safe-parse-number/index.ts

@@ -0,0 +1 @@
+export * from "./safe-parse-number";

package/templates/number/safe-parse-number/safe-parse-number.ts

@@ -0,0 +1,29 @@
+// 임의의 입력을 숫자로 안전하게 파싱한다. 파싱이 의미 없거나 실패하면
+// fallback(기본 0)을 돌려준다.
+//
+// Number()의 함정을 피하려고 사례별로 분기한다:
+//   - Number("")  === 0, Number("   ") === 0, Number(null) === 0  -> 의도와 다름.
+//     "빈 입력"은 0이 아니라 fallback이어야 하므로 문자열은 trim 후 빈값을 거른다.
+//   - Number([])  === 0, Number([5]) === 5  -> 배열/객체는 숫자로 보지 않고 fallback.
+//   - Number(true) === 1 -> boolean도 숫자가 아니므로 fallback.
+// number는 NaN만 거르고(±Infinity는 유효한 수로 통과), 그 외 타입은 문자열로
+// 만들어 trim한 뒤 Number로 변환한다. 결과가 NaN이면 fallback.
+export const safeParseNumber = (value: unknown, fallback = 0): number => {
+  if (typeof value === "number") {
+    return Number.isNaN(value) ? fallback : value;
+  }
+
+  // boolean/배열/객체 등은 Number()가 우연히 숫자를 뱉으므로 명시적으로 막는다.
+  if (typeof value !== "string" && typeof value !== "bigint") {
+    return fallback;
+  }
+
+  const text = String(value).trim();
+  if (text === "") {
+    return fallback;
+  }
+
+  const parsed = Number(text);
+
+  return Number.isNaN(parsed) ? fallback : parsed;
+};

package/templates/number/to-ordinal/index.ts

@@ -0,0 +1 @@
+export * from "./to-ordinal";

package/templates/number/to-ordinal/to-ordinal.ts

@@ -0,0 +1,28 @@
+// 정수를 영어 서수 문자열로 바꾼다. 1 -> "1st", 2 -> "2nd", 3 -> "3rd",
+// 그 외에는 "th". 음수 부호와 0은 그대로 보존한다 (0 -> "0th", -1 -> "-1st").
+//
+// 영어 서수 규칙의 핵심 예외는 11·12·13이다. 끝자리만 보면 각각 1·2·3이라
+// "st/nd/rd"가 될 것 같지만, 실제로는 "11th/12th/13th"다. 그래서 마지막 두
+// 자리(mod 100)가 11~13이면 무조건 "th"로 처리하고, 그 밖에서만 끝자리
+// (mod 10)로 "st/nd/rd"를 고른다.
+// 비교는 절댓값으로 한다 (-21 의 끝자리 판정이 부호에 흔들리지 않게).
+export const toOrdinal = (value: number): string => {
+  const integer = Math.trunc(value);
+  const abs = Math.abs(integer);
+  const lastTwo = abs % 100;
+  const lastOne = abs % 10;
+
+  let suffix = "th";
+  // 11~13은 예외라 끝자리와 무관하게 "th". 그 외에만 끝자리로 분기한다.
+  if (lastTwo < 11 || lastTwo > 13) {
+    if (lastOne === 1) {
+      suffix = "st";
+    } else if (lastOne === 2) {
+      suffix = "nd";
+    } else if (lastOne === 3) {
+      suffix = "rd";
+    }
+  }
+
+  return `${integer}${suffix}`;
+};

package/templates/object/deep-clone/deep-clone.ts

@@ -0,0 +1,47 @@
+// plain object와 array를 재귀 복제해 입력과 구조를 공유하지 않는 새 값을 만든다.
+// Date는 같은 시각의 새 인스턴스로 복제하고, 원시·함수 등 그 외 값은 참조를 그대로 유지한다.
+// 순환 참조는 고려하지 않는다.
+
+// 재귀 복제 대상인지 가르는 술어. array는 별도로 처리하므로 여기선 plain object만.
+// Object.prototype 또는 프로토타입이 없는 객체만 plain object로 본다.
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+/**
+ * value를 재귀 복제한 새 값을 반환한다.
+ *
+ * - plain object와 array는 새로 만들어 각 원소/값을 재귀 복제한다.
+ * - Date는 같은 시각(getTime)의 새 Date로 복제한다.
+ * - 그 외(원시·함수·클래스 인스턴스 등)는 복제하지 않고 참조를 그대로 둔다.
+ *
+ * 복제된 plain object/array를 수정해도 원본에 영향이 가지 않는다(중첩까지 분리된다).
+ * 순환 참조가 있는 입력에는 무한 재귀로 빠질 수 있어 지원하지 않는다.
+ */
+export const deepClone = <T>(value: T): T => {
+  // array: 새 배열에 원소를 하나씩 재귀 복제해 담는다.
+  if (Array.isArray(value)) {
+    return value.map((element) => deepClone(element)) as T;
+  }
+
+  // Date: 내부 시각만 옮긴 새 인스턴스. (Date는 plain object가 아니라 위에서 따로 처리)
+  if (value instanceof Date) {
+    return new Date(value.getTime()) as T;
+  }
+
+  // plain object: 키별로 값을 재귀 복제한 새 객체를 만든다.
+  if (isPlainObject(value)) {
+    const result: Record<string, unknown> = {};
+    for (const key of Object.keys(value)) {
+      result[key] = deepClone(value[key]);
+    }
+    return result as T;
+  }
+
+  // 원시·함수·그 외 객체: 복제하지 않고 참조(또는 값)를 그대로 반환한다.
+  return value;
+};

package/templates/object/deep-clone/index.ts

@@ -0,0 +1 @@
+export * from "./deep-clone";

package/templates/object/deep-equal/deep-equal.ts

@@ -0,0 +1,66 @@
+// 두 값의 깊은 동등성을 판정한다. plain object와 array는 구조를 재귀 비교하고,
+// 그 외(원시·Date·함수 등)는 자기 규칙으로 비교한다. 순환 참조는 고려하지 않는다.
+
+// 더 깊이 들어갈 대상인지 가르는 술어. array는 별도로 처리하므로 여기선 plain object만.
+// Object.prototype 또는 프로토타입이 없는 객체만 plain object로 본다.
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+/**
+ * a와 b가 깊은 값으로 동등한지 판정한다.
+ *
+ * - 원시는 SameValueZero로 비교한다(NaN끼리는 같다고, +0과 -0은 같다고 본다).
+ * - array는 길이와 각 원소를 순서대로 재귀 비교한다.
+ * - plain object는 키 집합과 각 키의 값을 재귀 비교한다.
+ * - Date는 같은 시각(getTime)이면 같다고 본다.
+ * - 한쪽만 array/object이거나 종류가 다르면 같지 않다.
+ *
+ * 순환 참조가 있는 입력에는 무한 재귀로 빠질 수 있어 지원하지 않는다.
+ */
+export const deepEqual = (a: unknown, b: unknown): boolean => {
+  // 같은 참조이거나 NaN끼리처럼 원시가 동일하면 즉시 참(SameValueZero).
+  if (Object.is(a, b)) {
+    return true;
+  }
+
+  // 여기부터 둘 다 객체여야 깊이 비교할 수 있다. 하나라도 객체가 아니면 다르다.
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+
+  // Date는 같은 시각이면 같다. 한쪽만 Date면 종류가 달라 같지 않다.
+  const aIsDate = a instanceof Date;
+  const bIsDate = b instanceof Date;
+  if (aIsDate || bIsDate) {
+    return aIsDate && bIsDate && a.getTime() === b.getTime();
+  }
+
+  // array는 array끼리만 같을 수 있다. 길이와 원소를 순서대로 재귀 비교한다.
+  const aIsArray = Array.isArray(a);
+  const bIsArray = Array.isArray(b);
+  if (aIsArray || bIsArray) {
+    if (!aIsArray || !bIsArray || a.length !== b.length) {
+      return false;
+    }
+    return a.every((value, index) => deepEqual(value, b[index]));
+  }
+
+  // 남은 건 plain object. 그 외 객체(Map/Set/클래스 인스턴스 등)는 비교 규칙이 없어 다르게 본다.
+  if (!isPlainObject(a) || !isPlainObject(b)) {
+    return false;
+  }
+
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+
+  // 키 집합이 같고(= b가 같은 키를 모두 가짐) 각 값이 깊게 같아야 한다.
+  return aKeys.every((key) => Object.hasOwn(b, key) && deepEqual(a[key], b[key]));
+};

package/templates/object/deep-equal/index.ts

@@ -0,0 +1 @@
+export * from "./deep-equal";

package/templates/object/deep-merge/deep-merge.ts

@@ -0,0 +1,49 @@
+// 중첩 plain object를 재귀 병합한다. 양쪽 모두 plain object인 키만 더 깊이 들어가고,
+// 배열·원시·Date 등 그 외 값은 source 쪽으로 통째 교체한다(병합하지 않는다).
+// 입력을 변형하지 않고 항상 새 객체를 반환하는 순수 함수다.
+
+// 재귀 경계를 정하는 술어. 더 깊이 병합할 수 있는 건 "plain object"뿐이다.
+// 배열·null·Date·Map 같은 특수 객체는 부분 병합하면 의미가 깨지므로 통째 교체 대상으로 둔다.
+// Object.prototype 또는 프로토타입이 없는(Object.create(null)) 객체만 plain object로 본다.
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+/**
+ * target과 source를 재귀 병합한 새 객체를 반환한다.
+ *
+ * - 같은 키에서 양쪽이 모두 plain object면 그 안으로 재귀해 병합한다.
+ * - 그 외(배열·원시·Date·null 등)는 source 값으로 교체한다. 배열은 원소별 병합하지 않는다.
+ * - source에만 있는 키는 그대로 추가되고, target에만 있는 키는 보존된다.
+ *
+ * target·source 어느 쪽도 변형하지 않는다. 중첩 객체도 새로 만들어 채우므로,
+ * 반환값을 수정해도 입력에 영향이 가지 않는다.
+ */
+export const deepMerge = <T extends object, S extends object>(target: T, source: S): T & S => {
+  // 한쪽이라도 plain object가 아니면 병합할 구조가 없다. source를 우선해 교체한다.
+  if (!isPlainObject(target) || !isPlainObject(source)) {
+    return source as unknown as T & S;
+  }
+
+  const result: Record<string, unknown> = { ...target };
+
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key as keyof S];
+    const targetValue = result[key];
+
+    // 양쪽이 모두 plain object일 때만 한 단계 더 깊이 병합한다.
+    if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+      continue;
+    }
+
+    // 그 외에는 source 값으로 교체한다.
+    result[key] = sourceValue;
+  }
+
+  return result as T & S;
+};

package/templates/object/deep-merge/index.ts

@@ -0,0 +1 @@
+export * from "./deep-merge";

package/templates/object/defaults/defaults.ts

@@ -0,0 +1,14 @@
+// obj에서 값이 없는(undefined) 키를 defaultValues로 채운 새 객체를 만든다.
+// obj에 이미 값이 있으면(undefined가 아니면) 그 값을 그대로 둔다.
+// 입력 객체들은 변형하지 않고, obj의 얕은 복사본 위에 빈 칸만 메운다.
+export const defaults = <T extends object>(obj: Partial<T>, defaultValues: T): T => {
+  const result = { ...obj } as T;
+
+  for (const key of Object.keys(defaultValues) as (keyof T)[]) {
+    if (result[key] === undefined) {
+      result[key] = defaultValues[key];
+    }
+  }
+
+  return result;
+};