@no-k/hermes 0.1.0

package/templates/object/defaults/index.ts

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

package/templates/object/filter-object/filter-object.ts

@@ -0,0 +1,11 @@
+import { type TypeofResult, getType } from "../../type/get-type/index";
+
+export const filterObject = (obj: Record<string, unknown>, filterTypes: Set<TypeofResult>) => {
+  const entries = Object.entries(obj).filter(([key, value]) => {
+    const type = getType(value);
+
+    return !filterTypes.has(type);
+  });
+
+  return Object.fromEntries(entries);
+};

package/templates/object/filter-object/index.ts

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

package/templates/object/get/get.ts

@@ -0,0 +1,75 @@
+// 경로 문자열로 중첩 객체/배열에 안전 접근하는 유틸.
+// "a.b[0].c" 같은 경로를 키 목록 ["a", "b", "0", "c"]로 쪼갠 뒤 한 단계씩 내려간다.
+// 중간에 null/undefined나 인덱싱 불가능한 값을 만나면 즉시 defaultValue로 빠진다.
+
+// "a.b[0].c" -> ["a", "b", "0", "c"]
+// 점 구분과 대괄호 인덱스를 모두 받는다. 대괄호 안 키(숫자/문자 모두)는 한 세그먼트로 본다.
+// 빈 세그먼트(예: 선행 점, 연속 점)는 버려서 "" 키로 잘못 내려가지 않게 한다.
+const parsePath = (path: string): string[] => {
+  const segments: string[] = [];
+  let current = "";
+
+  // [start, end) 구간에 모인 키를 확정한다. 빈 문자열은 버린다.
+  const flush = (): void => {
+    if (current.length > 0) {
+      segments.push(current);
+      current = "";
+    }
+  };
+
+  for (let i = 0; i < path.length; i += 1) {
+    const char = path[i];
+
+    if (char === ".") {
+      flush();
+      continue;
+    }
+
+    // 대괄호 시작: 직전까지의 키를 끊고, 닫는 괄호 전까지를 다음 키로 모은다.
+    if (char === "[") {
+      flush();
+      continue;
+    }
+
+    if (char === "]") {
+      flush();
+      continue;
+    }
+
+    current += char;
+  }
+
+  flush();
+
+  return segments;
+};
+
+// 값이 키로 인덱싱 가능한 객체/배열인지 좁힌다. null도 typeof로는 "object"라 따로 거른다.
+const isIndexable = (value: unknown): value is Record<string, unknown> => {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+};
+
+/**
+ * "a.b[0].c" 경로로 중첩 값을 안전하게 읽는다.
+ * 경로가 끊기면(중간이 null/undefined이거나 키가 없으면) defaultValue를 반환하고,
+ * defaultValue가 없으면 undefined를 반환한다.
+ *
+ * 입력 obj는 unknown으로 받아 어떤 값이든 던지지 않고 처리한다.
+ * 반환 타입은 호출부가 지정한 T로 단언한다(런타임 보장은 경로 존재 여부까지다).
+ */
+export const get = <T = unknown>(obj: unknown, path: string, defaultValue?: T): T => {
+  const segments = parsePath(path);
+
+  let cursor: unknown = obj;
+  for (const key of segments) {
+    if (!isIndexable(cursor)) {
+      return defaultValue as T;
+    }
+
+    cursor = cursor[key];
+  }
+
+  // 경로 끝까지 내려갔는데 값이 undefined면 "없음"으로 보고 defaultValue로 대체한다.
+  // (null은 명시적으로 들어있던 값이므로 그대로 돌려준다.)
+  return cursor === undefined ? (defaultValue as T) : (cursor as T);
+};

package/templates/object/get/index.ts

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

package/templates/object/has/has.ts

@@ -0,0 +1,60 @@
+// 경로 문자열로 중첩 객체/배열에 해당 키가 "존재하는지"만 판정하는 유틸.
+// get과 달리 값 자체(undefined/null 여부)는 보지 않고, 키 소유 여부만 본다.
+// 즉 { a: undefined }에서 has(obj, "a")는 true다.
+
+// "a.b[0].c" -> ["a", "b", "0", "c"]
+// 점 구분과 대괄호 인덱스를 모두 받는다. 빈 세그먼트는 버린다.
+const parsePath = (path: string): string[] => {
+  const segments: string[] = [];
+  let current = "";
+
+  const flush = (): void => {
+    if (current.length > 0) {
+      segments.push(current);
+      current = "";
+    }
+  };
+
+  for (let i = 0; i < path.length; i += 1) {
+    const char = path[i];
+
+    if (char === "." || char === "[" || char === "]") {
+      flush();
+      continue;
+    }
+
+    current += char;
+  }
+
+  flush();
+
+  return segments;
+};
+
+// 값이 키 소유 여부를 물어볼 수 있는 객체/배열인지 좁힌다. null은 거른다.
+const isIndexable = (value: unknown): value is Record<string, unknown> => {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+};
+
+/**
+ * "a.b[0]" 경로가 존재하는지 판정한다.
+ * 각 단계에서 현재 값이 인덱싱 가능한 객체이고 해당 키를 소유하면(Object.hasOwn) 다음으로 내려간다.
+ * 중간이라도 키가 없거나 인덱싱 불가능한 값을 만나면 false.
+ *
+ * 키 존재만 보므로 값이 undefined여도(예: { a: undefined }) 키를 소유하면 true다.
+ * 빈 경로("")는 세그먼트가 없어 항상 true(루트 자신은 존재).
+ */
+export const has = (obj: unknown, path: string): boolean => {
+  const segments = parsePath(path);
+
+  let cursor: unknown = obj;
+  for (const key of segments) {
+    if (!isIndexable(cursor) || !Object.hasOwn(cursor, key)) {
+      return false;
+    }
+
+    cursor = cursor[key];
+  }
+
+  return true;
+};

package/templates/object/has/index.ts

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

package/templates/object/invert/index.ts

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

package/templates/object/invert/invert.ts

@@ -0,0 +1,13 @@
+// 객체의 키와 값을 뒤집은 새 객체를 만든다. 원래 값이 새 키가 되고,
+// 원래 키가 새 값이 된다. 객체 키는 항상 문자열로 강제되므로 결과는
+// Record<string, string>이다. 서로 다른 키가 같은 값을 가리키면(값 충돌)
+// 등장 순서상 마지막 키가 우선한다. 입력 객체는 변형하지 않는다.
+export const invert = <T extends Record<PropertyKey, PropertyKey>>(obj: T): Record<string, string> => {
+  const result: Record<string, string> = {};
+
+  for (const key of Object.keys(obj)) {
+    result[String(obj[key])] = key;
+  }
+
+  return result;
+};

package/templates/object/map-keys/index.ts

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

package/templates/object/map-keys/map-keys.ts

@@ -0,0 +1,16 @@
+// 객체의 각 키를 keyFn으로 변환한 새 객체를 만든다. 값은 그대로 옮겨진다.
+// keyFn이 같은 키를 여러 번 돌려주면 나중 항목이 우선한다.
+// 자기 소유(own) 열거 가능 키만 다루며, 입력 객체는 변형하지 않는다.
+export const mapKeys = <T extends object, K extends PropertyKey>(
+  obj: T,
+  keyFn: (key: keyof T, value: T[keyof T]) => K,
+): Record<K, T[keyof T]> => {
+  const result = {} as Record<K, T[keyof T]>;
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    const value = obj[key];
+    result[keyFn(key, value)] = value;
+  }
+
+  return result;
+};

package/templates/object/map-values/index.ts

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

package/templates/object/map-values/map-values.ts

@@ -0,0 +1,14 @@
+// 객체의 각 값을 valueFn으로 변환한 새 객체를 만든다. 키는 그대로 보존된다.
+// 자기 소유(own) 열거 가능 키만 다루며, 입력 객체는 변형하지 않는다.
+export const mapValues = <T extends object, V>(
+  obj: T,
+  valueFn: (value: T[keyof T], key: keyof T) => V,
+): Record<keyof T, V> => {
+  const result = {} as Record<keyof T, V>;
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    result[key] = valueFn(obj[key], key);
+  }
+
+  return result;
+};

package/templates/object/omit/index.ts

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

package/templates/object/omit/omit.ts

@@ -0,0 +1,15 @@
+// 객체에서 지정한 키를 제외한 새 객체를 만드는 유틸.
+// 원본을 변형하지 않고, 제외할 키를 Set으로 모아 나머지 엔트리만 얕게 복사한다.
+// 자기 자신의 열거 가능 키만 순회하므로 상속 속성은 결과에 섞이지 않는다.
+export const omit = <T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> => {
+  const excluded = new Set<PropertyKey>(keys);
+  const result = {} as Record<PropertyKey, unknown>;
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    if (!excluded.has(key)) {
+      result[key] = obj[key];
+    }
+  }
+
+  return result as Omit<T, K>;
+};

package/templates/object/omit-by/index.ts

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

package/templates/object/omit-by/omit-by.ts

@@ -0,0 +1,19 @@
+// predicate를 통과한 엔트리를 제외한 새 객체를 만드는 유틸.
+// `pickBy`의 반대 동작이다: predicate가 참인 엔트리를 버리고 나머지를 남긴다.
+// 키가 아니라 값/키 조건으로 거르므로 반환 타입은 Partial<T>다.
+// 원본은 변형하지 않고 남은 엔트리만 얕게 복사한다.
+export const omitBy = <T extends object>(
+  obj: T,
+  predicate: (value: T[keyof T], key: keyof T) => boolean,
+): Partial<T> => {
+  const result: Partial<T> = {};
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    const value = obj[key];
+    if (!predicate(value, key)) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};

package/templates/object/pick/index.ts

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

package/templates/object/pick/pick.ts

@@ -0,0 +1,15 @@
+// 객체에서 지정한 키만 골라 새 객체를 만드는 유틸.
+// 원본을 변형하지 않고 얕은 복사로 선택된 엔트리만 담는다.
+// keys에 들어온 키라도 객체에 실제로 없으면(상속 속성 등) 건너뛰어,
+// 결과에 undefined 값 엔트리가 새로 생기지 않게 한다.
+export const pick = <T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> => {
+  const result = {} as Pick<T, K>;
+
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = obj[key];
+    }
+  }
+
+  return result;
+};

package/templates/object/pick-by/index.ts

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

package/templates/object/pick-by/pick-by.ts

@@ -0,0 +1,19 @@
+// predicate를 통과한 엔트리만 골라 새 객체를 만드는 유틸.
+// 키가 아니라 값/키 조건으로 거르므로 어떤 키가 남을지 정적으로 알 수 없다.
+// 그래서 반환 타입은 Partial<T>다 (모든 키가 빠질 수 있다).
+// 원본은 변형하지 않고 통과한 엔트리만 얕게 복사한다.
+export const pickBy = <T extends object>(
+  obj: T,
+  predicate: (value: T[keyof T], key: keyof T) => boolean,
+): Partial<T> => {
+  const result: Partial<T> = {};
+
+  for (const key of Object.keys(obj) as (keyof T)[]) {
+    const value = obj[key];
+    if (predicate(value, key)) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};

package/templates/object/set/index.ts

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

package/templates/object/set/set.ts

@@ -0,0 +1,118 @@
+// 경로 문자열 위치에 값을 설정한 "새" 객체를 반환하는 불변(immutable) 유틸.
+// 입력 obj는 변형하지 않고, 경로상에 놓인 객체/배열만 얕은 복사로 갈아끼운다(경로 밖 가지는 공유).
+// 중간 경로가 없으면 만들어 채우는데, 다음 세그먼트가 배열 인덱스면 배열을, 아니면 객체를 만든다.
+
+// 경로 세그먼트. 키 문자열과 "이 위치가 배열 인덱스인지"를 함께 들고 다닌다.
+// 인덱스 여부로 (1) 비어있는 중간 경로를 배열로 만들지 객체로 만들지, (2) 인덱스를 number로 쓸지를 정한다.
+interface Segment {
+  readonly key: string;
+  readonly isIndex: boolean;
+}
+
+// "a.b[0].c" -> [a, b, 0(index), c]
+// 점 뒤 키는 일반 키, 대괄호 안 키는 인덱스로 표시한다.
+// 점 표기라도 순수 숫자 문자열이면 인덱스로 본다(예: "a.0.b"의 0).
+const parsePath = (path: string): Segment[] => {
+  const segments: Segment[] = [];
+  let current = "";
+  // 지금 모으는 키가 대괄호 안에서 시작했는지. 그러면 무조건 인덱스로 본다.
+  let inBracket = false;
+
+  // 모인 키를 세그먼트로 확정한다. 빈 키는 버린다.
+  const flush = (): void => {
+    if (current.length > 0) {
+      // 대괄호 안이었거나, 점 표기라도 순수 정수 문자열이면 인덱스로 취급한다.
+      const isIndex = inBracket || /^\d+$/.test(current);
+      segments.push({ key: current, isIndex });
+      current = "";
+    }
+    inBracket = false;
+  };
+
+  for (let i = 0; i < path.length; i += 1) {
+    const char = path[i];
+
+    if (char === ".") {
+      flush();
+      continue;
+    }
+
+    if (char === "[") {
+      flush();
+      inBracket = true;
+      continue;
+    }
+
+    if (char === "]") {
+      flush();
+      continue;
+    }
+
+    current += char;
+  }
+
+  flush();
+
+  return segments;
+};
+
+// 값이 우리가 얕은 복사로 갈아끼울 수 있는 평범한 객체/배열인지 좁힌다. null은 거른다.
+const isContainer = (value: unknown): value is Record<string, unknown> | unknown[] => {
+  return value !== null && typeof value === "object";
+};
+
+// 다음 세그먼트의 인덱스 여부에 맞춰, 자리에 둘 빈 컨테이너를 고른다.
+const emptyContainerFor = (segment: Segment): Record<string, unknown> | unknown[] => {
+  return segment.isIndex ? [] : {};
+};
+
+// 컨테이너를 한 단계 얕은 복사한다. 배열은 배열로, 객체는 객체로 보존한다.
+const shallowClone = (value: Record<string, unknown> | unknown[]): Record<string, unknown> | unknown[] => {
+  return Array.isArray(value) ? value.slice() : { ...value };
+};
+
+// segments[depth]부터 재귀로 내려가며 복사본을 만들고, 마지막 위치에 value를 박는다.
+// node는 "현재 깊이에서 들어있던 값"(없을 수도 있어 unknown). 항상 새 컨테이너를 반환한다.
+const setIn = (
+  node: unknown,
+  segments: Segment[],
+  depth: number,
+  value: unknown,
+): Record<string, unknown> | unknown[] => {
+  const segment = segments[depth];
+  const isLast = depth === segments.length - 1;
+
+  // 현재 자리에 컨테이너가 있으면 복사해 쓰고, 없으면 다음 세그먼트 종류에 맞는 빈 컨테이너를 만든다.
+  // (배열 자리에 객체가 있는 식의 타입 불일치도 새 컨테이너로 교체해 일관성을 맞춘다.)
+  const base =
+    isContainer(node) && Array.isArray(node) === segment.isIndex ? shallowClone(node) : emptyContainerFor(segment);
+
+  // 배열이면 number 인덱스로, 객체면 string 키로 쓴다.
+  // (Array를 string 키로 인덱싱해도 동작하지만, 인덱스는 number로 다뤄 길이/희소 배열 의미를 살린다.)
+  if (Array.isArray(base)) {
+    const index = Number(segment.key);
+    base[index] = isLast ? value : setIn(base[index], segments, depth + 1, value);
+    return base;
+  }
+
+  base[segment.key] = isLast ? value : setIn(base[segment.key], segments, depth + 1, value);
+  return base;
+};
+
+/**
+ * "a.b[0].c" 경로에 value를 설정한 새 객체를 반환한다(입력 obj 불변).
+ * 경로상의 컨테이너만 얕은 복사로 교체하고, 경로 밖 가지는 원본과 그대로 공유한다.
+ * 중간 경로가 없으면 만들며, 다음 세그먼트가 인덱스면 배열을, 아니면 객체를 생성한다.
+ *
+ * 빈 경로("")면 설정할 위치가 없으므로 입력을 얕은 복사해 그대로 돌려준다.
+ * 반환 타입은 입력과 같은 T로 단언한다(경로 생성으로 구조가 넓어질 수 있음은 호출부 책임).
+ */
+export const set = <T extends object>(obj: T, path: string, value: unknown): T => {
+  const segments = parsePath(path);
+
+  if (segments.length === 0) {
+    return shallowClone(obj as Record<string, unknown> | unknown[]) as T;
+  }
+
+  return setIn(obj, segments, 0, value) as T;
+};

package/templates/string/capitalize/capitalize.ts

@@ -0,0 +1,4 @@
+// 첫 글자만 대문자로 만들고 나머지는 그대로 둔다. 빈 문자열은 빈 문자열 그대로.
+export const capitalize = (word: string): string => {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+};

package/templates/string/capitalize/index.ts

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

package/templates/string/change-case/change-case.ts

@@ -0,0 +1,98 @@
+import { capitalize } from "../capitalize/index";
+import { isAsciiDigit, isAsciiLower, isAsciiUpper } from "../char/index";
+
+// 케이스 변환 유틸. splitWords가 어떤 케이스든 소문자 단어 배열로 쪼개고,
+// toXxxCase 조립기가 타깃 케이스로 다시 합친다.
+// 이 구조라 케이스 간 변환이 N×N 조합 없이 전부 동작한다 (kebab->Pascal, snake->camel, ...).
+
+// 단어를 끊는 구분자. 공백류와 `.` `_` `-`. (원본 정규식의 `[\s._-]`와 동일한 문자 집합)
+// 비ASCII 글자는 여기 안 걸리므로 단어 안에 그대로 보존된다 (글자를 흘리지 않는다).
+const SEPARATOR = /[\s._-]/;
+
+/**
+ * 어떤 케이스의 문자열이든 소문자 단어 배열로 쪼갠다.
+ * 모든 toXxxCase가 이 결과를 조립하므로, 이 함수의 분할 규칙이 곧 변환 전체의 동작을 정한다.
+ *
+ * 정규식 체인(replace x2 -> split -> filter -> map) 대신 문자 단위 단일 패스로 구현했다.
+ * core 라이브러리라 길거나 신뢰할 수 없는 입력이 들어올 수 있는데,
+ * 정규식 `([A-Z]+)([A-Z][a-z])`는 긴 대문자 런에서 O(n^2) 백트래킹이 난다.
+ * 단일 패스는 O(n)이고 중간 문자열/배열 할당도 없다.
+ *
+ * 새 단어가 시작되는 경계는 둘 중 하나다 (대문자 A-Z에서만 판정):
+ *   1. 소문자/숫자 다음의 대문자        : "fooBar"     -> foo | Bar
+ *   2. 대문자 런의 끝(= 다음이 소문자)  : "HTMLParser" -> HTML | Parser
+ * 구분자(SEPARATOR)는 단어를 끊고 결과에서 빠진다.
+ * 머리글자 묶음은 단어로 쪼갠 뒤 소문자로 정규화된다 ("HTMLParser" -> ["html", "parser"]).
+ */
+export const splitWords = (input: string): string[] => {
+  const words: string[] = [];
+  // 현재 모으는 중인 단어의 시작 인덱스. 단어 밖이면 -1.
+  let start = -1;
+
+  // [start, end) 구간을 한 단어로 확정한다.
+  const flush = (end: number): void => {
+    if (start >= 0) {
+      words.push(input.slice(start, end).toLowerCase());
+      start = -1;
+    }
+  };
+
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+
+    // 구분자: 진행 중이던 단어를 끊고 이 문자 자체는 버린다.
+    if (SEPARATOR.test(char)) {
+      flush(i);
+      continue;
+    }
+
+    // 단어의 첫 글자: 시작점만 잡고 넘어간다 (경계 판정 대상 아님).
+    if (start < 0) {
+      start = i;
+      continue;
+    }
+
+    // 단어 중간의 대문자만 새 단어의 경계가 될 수 있다.
+    if (isAsciiUpper(char)) {
+      const prev = input[i - 1];
+      const next = input[i + 1];
+      // 규칙 1: "fooBar" 의 B — 소문자/숫자 바로 뒤의 대문자
+      const afterLowerOrDigit = isAsciiLower(prev) || isAsciiDigit(prev);
+      // 규칙 2: "HTMLParser" 의 P — 대문자 런의 마지막(다음 글자가 소문자)
+      const acronymThenWord = isAsciiUpper(prev) && isAsciiLower(next);
+      if (afterLowerOrDigit || acronymThenWord) {
+        flush(i);
+        start = i;
+      }
+    }
+  }
+
+  // 마지막 단어 확정.
+  flush(input.length);
+
+  return words;
+};
+
+export const toCamelCase = (input: string): string => {
+  return splitWords(input)
+    .map((word, index) => (index === 0 ? word : capitalize(word)))
+    .join("");
+};
+
+export const toPascalCase = (input: string): string => {
+  return splitWords(input).map(capitalize).join("");
+};
+
+export const toKebabCase = (input: string): string => {
+  return splitWords(input).join("-");
+};
+
+export const toSnakeCase = (input: string): string => {
+  return splitWords(input).join("_");
+};
+
+export const toConstantCase = (input: string): string => {
+  return splitWords(input)
+    .map((word) => word.toUpperCase())
+    .join("_");
+};

package/templates/string/change-case/index.ts

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

package/templates/string/char/char.ts

@@ -0,0 +1,14 @@
+// ASCII 문자 분류 술어. 단일 문자를 받아 종류를 판별한다.
+// 로캘/유니코드 영향 없이 항상 같은 결과를 주는 결정론적 분류용이라,
+// 파싱·토크나이즈 같은 곳에서 정규식보다 가볍게 재사용한다.
+// (빈 자리나 범위 밖 문자에는 false를 돌려줘 경계에서 안전하다.)
+
+export const isAsciiUpper = (char: string): boolean => char >= "A" && char <= "Z";
+
+export const isAsciiLower = (char: string): boolean => char >= "a" && char <= "z";
+
+export const isAsciiDigit = (char: string): boolean => char >= "0" && char <= "9";
+
+export const isAsciiLetter = (char: string): boolean => isAsciiUpper(char) || isAsciiLower(char);
+
+export const isAsciiAlphanumeric = (char: string): boolean => isAsciiLetter(char) || isAsciiDigit(char);

package/templates/string/char/index.ts

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

package/templates/string/count-occurrences/count-occurrences.ts

@@ -0,0 +1,20 @@
+// str 안에서 search가 겹치지 않게 등장하는 횟수를 센다. 입력은 변형하지 않는다.
+// search가 ""이면 0을 반환한다 (빈 문자열은 모든 위치에 무한히 매칭되므로 정의상 제외).
+//
+// 매칭 후 인덱스를 search.length만큼 건너뛰어 겹침을 막는다.
+// 예: countOccurrences("aaaa", "aa")는 [0..2)와 [2..4) 두 번 -> 2 (1,2,3에서 다시 세지 않음).
+export const countOccurrences = (str: string, search: string): number => {
+  if (search === "") {
+    return 0;
+  }
+
+  let count = 0;
+  let index = str.indexOf(search);
+
+  while (index !== -1) {
+    count += 1;
+    index = str.indexOf(search, index + search.length);
+  }
+
+  return count;
+};

package/templates/string/count-occurrences/index.ts

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

package/templates/string/escape-html/escape-html.ts

@@ -0,0 +1,16 @@
+// HTML 특수문자를 엔티티로 치환한다. 텍스트를 마크업에 안전하게 끼워 넣을 때 쓴다.
+// 입력은 변형하지 않고 새 문자열을 반환한다.
+//
+// `&`를 가장 먼저 치환해야 한다. 뒤에 치환하면 이미 만든 엔티티의 `&`까지
+// 다시 `&amp;`로 이중 치환된다(`<` -> `&lt;` -> `&amp;lt;`). 그래서 순서가 중요하다.
+const HTML_ENTITIES: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+
+export const escapeHtml = (str: string): string => {
+  return str.replace(/[&<>"']/g, (char) => HTML_ENTITIES[char]);
+};

package/templates/string/escape-html/index.ts

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

package/templates/string/get-decorated-string/get-decorated-string.ts

@@ -0,0 +1,7 @@
+const selection = "___FORMAT___";
+
+export const getDecoratedString = (target: string, toBe: string) => {
+  return toBe.replace(new RegExp(selection, "g"), target);
+};
+
+getDecoratedString.selection = selection;

package/templates/string/get-decorated-string/index.ts

@@ -0,0 +1 @@
+export * from "./get-decorated-string";

package/templates/string/is-blank/index.ts

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

package/templates/string/is-blank/is-blank.ts

@@ -0,0 +1,6 @@
+// 빈 문자열이거나 공백 문자만 있으면 true. 입력은 변형하지 않는다.
+// `trim()`이 양 끝의 공백류(스페이스, 탭, 개행, NBSP 등 유니코드 공백)를 모두
+// 제거하므로, 전부 공백이면 결과가 ""가 된다. 따라서 trim 결과의 빈 여부 한 번으로 판정된다.
+export const isBlank = (str: string): boolean => {
+  return str.trim() === "";
+};

package/templates/string/mask/index.ts

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