wip

@sammo/crypto/src/AES.ts

@@ -1,4 +1,4 @@
-import type { BufferSource } from "./types.js";
+import type { BufferSource } from "@sammo/util";
 
 const subtle = globalThis.crypto.subtle;
 

@sammo/crypto/src/LiteHashDRBG.ts

@@ -0,0 +1,264 @@
+import type { RNG } from "../../../server/util/RNG.js";
+
+import { sha512 } from '../../../server/util/sha2.js';
+
+import { convertBytesLikeToUint8Array } from "@sammo/util/convertBytesLikeToUint8Array.js";
+import type { BytesLike } from "../../../server/util/BytesLike.js";
+import { delay } from "./delay.js";
+
+const maxRngSupportBit = 53;
+const maxInt = 0x1f_ffff_ffff_ffff; //      NOTE: b 0, 10000110011, 11...11
+const maxIntMore1 = 0x20_0000_0000_0000n; //NOTE: b 0, 10000110100, 00...00
+const maxIntMore1f = Number(maxIntMore1);
+export const bufferByteSize = 512 / 8; //SHA512
+
+const intBitMapMask = new Map([
+    [0x1n, 1],
+    [0x3n, 2],
+    [0x7n, 3],
+    [0xfn, 4],
+    [0x1fn, 5],
+    [0x3fn, 6],
+    [0x7fn, 7],
+    [0xffn, 8],
+    [0x1ffn, 9],
+    [0x3ffn, 10],
+    [0x7ffn, 11],
+    [0xfffn, 12],
+    [0x1fffn, 13],
+    [0x3fffn, 14],
+    [0x7fffn, 15],
+    [0xffffn, 16],
+    [0x1ffffn, 17],
+    [0x3ffffn, 18],
+    [0x7ffffn, 19],
+    [0xfffffn, 20],
+    [0x1fffffn, 21],
+    [0x3fffffn, 22],
+    [0x7fffffn, 23],
+    [0xffffffn, 24],
+    [0x1ffffffn, 25],
+    [0x3ffffffn, 26],
+    [0x7ffffffn, 27],
+    [0xfffffffn, 28],
+    [0x1fffffffn, 29],
+    [0x3fffffffn, 30],
+    [0x7fffffffn, 31],
+    [0xffffffffn, 32],
+    [0x1ffffffffn, 33],
+    [0x3ffffffffn, 34],
+    [0x7ffffffffn, 35],
+    [0xfffffffffn, 36],
+    [0x1fffffffffn, 37],
+    [0x3fffffffffn, 38],
+    [0x7fffffffffn, 39],
+    [0xffffffffffn, 40],
+    [0x1ffffffffffn, 41],
+    [0x3ffffffffffn, 42],
+    [0x7ffffffffffn, 43],
+    [0xfffffffffffn, 44],
+    [0x1fffffffffffn, 45],
+    [0x3fffffffffffn, 46],
+    [0x7fffffffffffn, 47],
+    [0xffffffffffffn, 48],
+    [0x1ffffffffffffn, 49],
+    [0x3ffffffffffffn, 50],
+    [0x7ffffffffffffn, 51],
+    [0xfffffffffffffn, 52],
+    [0x1fffffffffffffn, 53],
+]);
+
+function calcBitMask(n: bigint): bigint {
+    n |= n >> 1n;
+    n |= n >> 2n;
+    n |= n >> 4n;
+    n |= n >> 8n;
+    n |= n >> 16n;
+    n |= n >> 32n;
+
+    return n;
+}
+export class LiteHashDRBG implements RNG {
+
+    protected buffer!: ArrayBuffer;
+    protected bufferIdx!: number;
+    protected hq: DataView;
+    protected hqIdxPos: number;
+
+    protected ready: Promise<void>;
+
+    public constructor(protected seed: BytesLike, protected stateIdx = 0, bufferIdx = 0) {
+        if (bufferIdx < 0) {
+            throw new Error(`bufferIdx ${bufferIdx} < 0`);
+        }
+        if (bufferIdx >= bufferByteSize) {
+            throw new Error(`bufferidx ${bufferIdx} >= ${bufferByteSize}`);
+        }
+        if (stateIdx < 0) {
+            throw new Error(`stateIdx ${stateIdx} < 0`);
+        }
+
+        const seedU8 = convertBytesLikeToUint8Array(seed);
+        const hqBuffer = new ArrayBuffer(seedU8.byteLength + 4);
+        const hqU8 = new Uint8Array(hqBuffer);
+
+        hqU8.set(seedU8, 0);
+        this.hq = new DataView(hqBuffer);
+        this.hqIdxPos = seedU8.byteLength;
+
+        this.ready = this.genNextBlock();
+        this.bufferIdx = bufferIdx;
+    }
+
+    protected async genNextBlock(): Promise<void> {
+        this.bufferIdx = 0;
+        this.hq.setUint32(this.hqIdxPos, this.stateIdx, true);
+        this.stateIdx += 1;
+        const digest = await sha512(this.hq.buffer);
+        this.buffer = digest;
+    }
+
+    public getMaxInt(): number {
+        return maxInt;
+    }
+
+    public async nextBytes(bytes: number, baseBytes?: number): Promise<Uint8Array> {
+        bytes |= 0;
+        if (bytes <= 0) {
+            throw new Error(`${bytes} <= 0`);
+        }
+
+        const ticket = this.ready;
+
+        let waiter: Promise<Uint8Array | undefined> = Promise.resolve(undefined);
+
+        let nextBlockWait: (() => void) | null = (() => { throw 'something wrong'; });
+
+        this.ready = new Promise((resolve, reject) => {
+            waiter = (async () => {
+                await ticket;
+                nextBlockWait = resolve;
+
+                if (this.bufferIdx + bytes <= bufferByteSize) {
+                    if (baseBytes === undefined || bytes >= baseBytes) {
+                        const result = this.buffer.slice(this.bufferIdx, this.bufferIdx + bytes);
+                        this.bufferIdx += bytes;
+                        if (this.bufferIdx === bufferByteSize) {
+                            nextBlockWait = null;
+                            this.genNextBlock().then(resolve, reject);
+                        }
+                        return new Uint8Array(result);
+                    }
+
+                    const resultBuffer = new ArrayBuffer(Math.max(bytes, baseBytes ?? 0));
+                    const result = new Uint8Array(resultBuffer);
+                    result.set(new Uint8Array(this.buffer, this.bufferIdx, bytes));
+                    this.bufferIdx += bytes;
+                    if (this.bufferIdx === bufferByteSize) {
+                        nextBlockWait = null;
+                        this.genNextBlock().then(resolve, reject);
+                    }
+                    return result;
+                }
+
+                const resultBuffer = new ArrayBuffer(baseBytes ? Math.max(bytes, baseBytes) : bytes);
+                const result = new Uint8Array(resultBuffer);
+
+                result.set(new Uint8Array(this.buffer, this.bufferIdx));
+                let offset = bufferByteSize - this.bufferIdx;
+                let remain = bytes - offset;
+
+                while (remain > bufferByteSize) {
+                    await this.genNextBlock();
+                    result.set(new Uint8Array(this.buffer), offset);
+                    offset += bufferByteSize;
+                    remain -= bufferByteSize;
+                }
+
+                if (remain === 0) {
+                    nextBlockWait = null;
+                    this.genNextBlock().then(resolve, reject);
+                    return result;
+                }
+
+                await this.genNextBlock();
+                result.set(new Uint8Array(this.buffer, 0, remain), offset);
+                this.bufferIdx = remain;
+                return result;
+            })();
+
+        });
+
+        //이 코드를 통해 Promise 내부가 실행된다
+        await delay(0);
+
+        const nextBlock = await waiter;
+        if (nextBlockWait) {
+            nextBlockWait();
+        }
+        return nextBlock as Uint8Array;
+    }
+
+    public async nextBits(bits: number, baseBytes?: number): Promise<Uint8Array> {
+        await this.ready;
+
+        bits |= 0;
+        const bytes = (bits + 7) >> 3;
+        const headBits = bits & 0x7;
+
+        const result = await this.nextBytes(bytes, baseBytes);
+        if (headBits === 0) {
+            return result;
+        }
+
+        result[bytes - 1] &= 0xff >> (8 - headBits);
+        return result;
+    }
+
+    protected async _nextInt(bits: number): Promise<bigint> {
+        const buffer = await this.nextBits(bits, 8);
+        const dataView = new DataView(buffer.buffer);
+        return dataView.getBigUint64(0, true);
+    }
+
+    public async nextInt(max?: number): Promise<number> {
+        if (max === undefined || max === maxInt) {
+            return Number(await this._nextInt(maxRngSupportBit));
+        }
+        if (max > maxInt) {
+            throw new Error('Over max int');
+        }
+        if (max === 0) {
+            return 0;
+        }
+        if (max < 0) {
+            return -this.nextInt(-max);
+        }
+
+        const mask = calcBitMask(BigInt(max));
+        const bits = intBitMapMask.get(mask) as number;
+
+        let n = Number(this._nextInt(bits));
+        while (n > max) {
+            n = Number(this._nextInt(bits));
+        }
+        return n;
+    }
+
+    public async nextFloat1(): Promise<number> {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nInt = await this._nextInt(maxRngSupportBit + 1);
+            if (nInt < maxIntMore1) {
+                return Number(nInt) / maxIntMore1f;
+            }
+            if (nInt === maxIntMore1) {
+                return 1;
+            }
+        }
+    }
+
+    public static build(seed: BytesLike, stateIdx = 0): LiteHashDRBG {
+        return new LiteHashDRBG(seed, stateIdx);
+    }
+}

@sammo/crypto/src/index.ts

@@ -103,4 +103,6 @@ export * as RawTypes from './RawTypes.js';
 
 export * from './utils.js';
 export * from './types.js';
-export { TypeLength } from './TypeLength.js';
+export { TypeLength } from './TypeLength.js';
+
+export * from "./LiteHashDRBG.js"

@sammo/crypto/src/types.ts

@@ -1,4 +1,3 @@
-export type BufferSource = ArrayBufferView | ArrayBuffer | SharedArrayBuffer;
 
 export function isBufferSource(obj: unknown): obj is BufferSource {
 	if (obj instanceof ArrayBuffer){

@sammo/gateway/src/api/Login/LoginByID.ts

@@ -3,7 +3,7 @@ import { StartSession } from "@sammo/server_util";
 import { POST, type APIReturnType } from "@strpc/express";
 import { declProcDecorators } from "@strpc/express/proc_decorator";
 import { z } from "zod";
-import { loginCtxSessionKey, type GatewayLoginCtx } from "../../procDecorator/ReqGatewayLogin.js";
+import { loginCtxSessionKey, type GatewayLoginCtx } from "@/procDecorator/ReqGatewayLogin.js";
 import { delay } from "@sammo/util";
 
 type BaseAPI = typeof structure.Login.LoginByID;

@sammo/gateway/src/api/Login/index.ts

@@ -1,5 +1,5 @@
-import type { structure } from "../../../apiStructure/sammoGatewayAPI.js";
-import type { APINamespaceType } from "../../defs.js";
+import type { structure } from "@sammo/api_def/gateway";
+import type { APINamespaceType } from "@strpc/express";
 import { LoginByID } from "./LoginByID.js";
 import { LoginByToken } from "./LoginByToken.js";
 import { ReqNonce } from "./ReqNonce.js";

@sammo/util/package.json

@@ -6,11 +6,18 @@
   "scripts": {
     "build": "tsc --build"
   },
+  "exports": {
+    ".": "./dist/index.js",
+    "./converter": "./dist/converter.js",
+    "./datetime": "./dist/datetime.js",
+    "./korean": "./dist/korean.js"
+  },
   "type": "module",
   "keywords": [],
   "author": "",
   "license": "MIT",
   "devDependencies": {
+    "@types/node": "^20.6.3",
     "lodash-es": "^4.17.21"
   },
   "peerDependencies": {

@sammo/util/src/converter/combineArray.ts

@@ -0,0 +1,11 @@
+import { combineObject } from "./combineObject.js";
+
+
+export function combineArray<K extends string, V>(array: V[][], columnList: K[]): Record<K, V>[] {
+    const result: Record<K, V>[] = [];
+    for (const key of array.keys()) {
+        const item = array[key];
+        result[key] = combineObject(item, columnList);
+    }
+    return result;
+}

@sammo/util/src/converter/combineObject.ts

@@ -0,0 +1,8 @@
+export function combineObject<K extends string, V>(item: V[], columnList: K[]): Record<K, V> {
+    const newItem: Record<string, V> = {};
+    for (const columnIdx in columnList) {
+        const columnName = columnList[columnIdx];
+        newItem[columnName] = item[columnIdx];
+    }
+    return newItem;
+}

@sammo/util/src/converter/convertBytesLikeToArrayBuffer.ts

@@ -0,0 +1,17 @@
+import type { BytesLike } from "./BytesLike.js";
+
+export function convertBytesLikeToArrayBuffer(data: BytesLike, encodeUTF8 = true): ArrayBuffer{
+    if (data instanceof ArrayBuffer) {
+        return data;
+    }
+    if (data instanceof Uint8Array) {
+        return data.buffer;
+    }
+    if (typeof(data) === 'string'){
+        if(encodeUTF8){
+            return (new TextEncoder()).encode(data);
+        }
+        return new Uint8Array(data.split('').map(s=>s.codePointAt(0) as number));
+    }
+    return data.buffer;
+}

@sammo/util/src/converter/convertBytesLikeToUint8Array.ts

@@ -0,0 +1,17 @@
+import type { BytesLike } from "./BytesLike.js";
+
+export function convertBytesLikeToUint8Array(data: BytesLike, encodeUTF8 = true): Uint8Array {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    if (typeof (data) === 'string') {
+        if(encodeUTF8){
+            return (new TextEncoder()).encode(data);
+        }
+        return new Uint8Array(data.split('').map(s=>s.codePointAt(0) as number));
+    }
+    return new Uint8Array(data.buffer);
+}

@sammo/util/src/converter/convertIDArray.ts

@@ -0,0 +1,9 @@
+import type { IDItem } from "../types.js";
+
+export function convertIDArray<T>(array: Iterable<T>): IDItem<T>[] {
+    const result: IDItem<T>[] = [];
+    for (const id of array) {
+        result.push({ id });
+    }
+    return result;
+}

@sammo/util/src/converter/convertIterableToMap.ts

@@ -0,0 +1,10 @@
+export function convertIterableToMap<T extends object, K extends keyof T, V extends T[K] & (string | number | symbol)>(
+  values: Iterable<T>,
+  key: K
+): Map<V, T> {
+  const result = new Map<V, T>();
+  for (const obj of values) {
+    result.set(obj[key] as V, obj);
+  }
+  return result;
+}

@sammo/util/src/converter/index.ts

@@ -0,0 +1,6 @@
+export * from "./combineObject.js";
+export * from "./combineArray.js";
+export * from "./convertBytesLikeToArrayBuffer.js";
+export * from "./convertBytesLikeToUint8Array.js";
+export * from "./convertIDArray.js";
+export * from "./convertIterableToMap.js"

@sammo/util/src/datetime/formatTime.ts

@@ -0,0 +1,18 @@
+import { format, formatISO9075 } from 'date-fns';
+//const DATE_TIME_FORMAT = 'yyyy-MM-dd HH:mm:ss';
+const DATE_TIME_FORMAT_WITH_FRACTION = 'yyyy-MM-dd HH:mm:ss.SSS';
+
+export function formatTime(time: Date, withFraction?:boolean): string;
+export function formatTime(time: Date, format:string): string;
+
+export function formatTime(time: Date, withFractionOrFormat:string|boolean = false): string {
+    if (typeof withFractionOrFormat === "string") {
+        return format(time, withFractionOrFormat);
+    }
+    else if(withFractionOrFormat){
+        return format(time, DATE_TIME_FORMAT_WITH_FRACTION);
+    }
+    else {
+        return formatISO9075(time);
+    }
+}

@sammo/util/src/datetime/index.ts

@@ -0,0 +1,3 @@
+export * from "./formatTime.js";
+export * from "./parseTime.js";
+export * from "./parseYearMonth.js";

@sammo/util/src/datetime/parseTime.ts

@@ -0,0 +1,5 @@
+import {parseISO} from 'date-fns';
+
+export function parseTime(dateString: string): Date{
+    return parseISO(dateString);
+}

@sammo/util/src/datetime/parseYearMonth.ts

@@ -0,0 +1,3 @@
+export function parseYearMonth(yearMonth: number): [number, number] {
+    return [(yearMonth / 12) | 0, yearMonth % 12 + 1];
+}

@sammo/util/src/index.ts

@@ -4,6 +4,12 @@ export * from "./error.js"
 export * from "./unwrap.js"
 export * from "./types.js"
 
+export * as converter from "./converter/index.js"
+export * as datetime from "./datetime/index.js"
+export * as korean from "./korean/index.js"
+
+import type { WrappedBuffer } from "./types.js"
+
 export function isEmail(addr: string): boolean {
 	return String(addr)
 		.toLowerCase()
@@ -23,12 +29,6 @@ export function calcBase64Len(length: number) {
 	return ((4 * length / 3) + 3) & ~3;
 }
 
-/** Buffer이지만 ts에서 타입 구분 편의를 제공 */
-export interface WrappedBuffer extends Buffer {
-	/** 타입구분자. 항상 undefined일 것이다 */
-	_w_type?: string;
-}
-
 /** ArrayBuffer,Uint8Array,Buffer를 WrappedBuffer로 변환
  */
 export function wrapBuffer<T extends WrappedBuffer>(buffer: BufferSource): T {
@@ -65,15 +65,6 @@ export function delay<T = undefined>(time: number, result?: T): Promise<T | void
 	);
 }
 
-/**
- * base64 string에 내부 타입으로 WrappedBuffer를 보관한 형태
- */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export type Base64String<T extends Buffer> = string & {
-	/** 타입구분자. 항상 undefined일 것이다 */
-	_b_type?: T;
-}
-
 export function base64FromWrappedBuffer<T extends WrappedBuffer>(buffer: T | ArrayBuffer | Uint8Array): Base64String<T> {
 	return Buffer.from(buffer).toString('base64');
 }
@@ -81,3 +72,17 @@ export function base64FromWrappedBuffer<T extends WrappedBuffer>(buffer: T | Arr
 export function wrappedBufferFromBase64<T extends WrappedBuffer>(base64: Base64String<T>): T {
 	return Buffer.from(base64, 'base64') as T;
 }
+
+
+export function isBufferSource(obj: unknown): obj is BufferSource {
+	if (obj instanceof ArrayBuffer){
+		return true;
+	}
+	if('SharedArrayBuffer' in globalThis && obj instanceof SharedArrayBuffer){
+		return true;
+	}
+	if (ArrayBuffer.isView(obj)){
+		return true;
+	}
+	return false;
+}

@sammo/util/src/korean/automata초성.ts

@@ -0,0 +1,101 @@
+const convListLevel1: Record<string, Record<string, string>> = {
+    'ㄱ': {
+        'ㅅ': 'ㄳ',
+    },
+    'ㄴ': {
+        'ㅈ': 'ㄵ',
+        'ㅎ': 'ㄶ',
+    },
+    'ㄹ': {
+        'ㅂ': 'ㄼ',
+        'ㄱ': 'ㄺ',
+        'ㅅ': 'ㄽ',
+        'ㅁ': 'ㄻ',
+        'ㅎ': 'ㅀ',
+        'ㅌ': 'ㄾ',
+        'ㅍ': 'ㄿ',
+    },
+    'ㅂ': {
+        'ㅅ': 'ㅄ',
+    },
+}
+
+const convListLevel2: Record<string, Record<string, string>> = {
+    'ㄱ': {
+        'ㄱ': 'ㄲ',
+        'ㅅ': 'ㄳ',
+    },
+    'ㄴ': {
+        'ㅈ': 'ㄵ',
+        'ㅎ': 'ㄶ',
+    },
+    'ㄷ': {
+        'ㄷ': 'ㄸ',
+    },
+    'ㄹ': {
+        'ㅂ': 'ㄼ',
+        'ㄱ': 'ㄺ',
+        'ㅅ': 'ㄽ',
+        'ㅁ': 'ㄻ',
+        'ㅎ': 'ㅀ',
+        'ㅌ': 'ㄾ',
+        'ㅍ': 'ㄿ',
+    },
+    'ㅂ': {
+        'ㅂ': 'ㅃ',
+        'ㅅ': 'ㅄ',
+    },
+    'ㅅ': {
+        'ㅅ': 'ㅆ',
+    },
+    'ㅈ': {
+        'ㅈ': 'ㅉ',
+    }
+}
+
+function automata초성(text: string, convList: Record<string, Record<string, string>>): string{
+    const result: string[] = [];
+    let head: undefined | string = undefined;
+    for (const ch of text) {
+        if (head === undefined) {
+            if(!(ch in convList)){
+                result.push(ch);
+                continue;
+            }
+            head = ch;
+            continue;
+        }
+
+        const nextConv = convList[head];
+        if(ch in nextConv){
+            result.push(nextConv[ch]);
+            head = undefined;
+            continue;
+        }
+
+        result.push(head);
+        if(!(ch in convList)){
+            result.push(ch);
+            head = undefined;
+            continue;
+        }
+        head = ch;
+    }
+    if(head !== undefined){
+        result.push(head);
+        head = undefined;
+    }
+    return result.join('');
+}
+
+export function automata초성All(text: string): [string, string]{
+    return [automata초성(text, convListLevel1), automata초성(text, convListLevel2)];
+}
+
+export function automata초성Level1(text: string): string{
+    return automata초성(text, convListLevel1);
+}
+
+export function automata초성Level2(text: string): string {
+    return automata초성(text, convListLevel2);
+}

@sammo/util/src/korean/convertSearch초성.ts

@@ -0,0 +1,9 @@
+import { automata초성All } from "./automata초성.js";
+import { filter초성withAlphabet } from "./filter초성withAlphabet.js";
+
+export function convertSearch초성(text: string): string[]{
+    const [filteredTextH, filteredTextA] = filter초성withAlphabet(text.replace(/\s+/g, ""));
+    const [filteredTextHL1, filteredTextHL2] = automata초성All(filteredTextH);
+
+    return [text, filteredTextA, filteredTextH, filteredTextHL1, filteredTextHL2];
+}

@sammo/util/src/korean/filter초성.ts

@@ -0,0 +1,17 @@
+export function filter초성(text: string): string {
+    const 초성 = [
+        "ㄱ", "ㄲ", "ㄴ", "ㄷ", "ㄸ", "ㄹ", "ㅁ", "ㅂ", "ㅃ",
+        "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅉ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ"
+    ];
+    const result: string[] = [];
+    for (const char of text) {
+        const code = (char.codePointAt(0) ?? 0) - 44032;
+        if (0 <= code && code < 11172) {
+            result.push(초성[~~(code / 588)]);
+        }
+        else {
+            result.push(char);
+        }
+    }
+    return result.join('');
+}

@sammo/util/src/korean/filter초성withAlphabet.ts

@@ -0,0 +1,24 @@
+export function filter초성withAlphabet(text: string): [string, string] {
+    const 초성 = [
+        "ㄱ", "ㄲ", "ㄴ", "ㄷ", "ㄸ", "ㄹ", "ㅁ", "ㅂ", "ㅃ",
+        "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅉ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ"
+    ];
+    const alphabets = [
+        "r", "R", "s", "e", "E", "f", "a", "q", "Q",
+        "t", "T", "d", "w", "W", "c", "z", "x", "v", "g"
+    ];
+    const resultH: string[] = [];
+    const resultA: string[] = [];
+    for (const char of text) {
+        const code = (char.codePointAt(0) ?? 0) - 44032;
+        if (0 <= code && code < 11172) {
+            resultH.push(초성[~~(code / 588)]);
+            resultA.push(alphabets[~~(code / 588)]);
+        }
+        else {
+            resultH.push(char);
+            resultA.push(char);
+        }
+    }
+    return [resultH.join(''), resultA.join('')];
+}

@sammo/util/src/korean/index.ts

@@ -0,0 +1,4 @@
+export * from "./automata초성.js";
+export * from "./convertSearch초성.js"
+export * from "./filter초성.js";
+export * from "./filter초성withAlphabet.js";

@sammo/util/src/types.ts

@@ -1 +1,28 @@
-export type Nullable<T> = T | null | undefined;
+export type Nullable<T> = T | null | undefined;
+
+export declare type ValuesOf<T> = T[keyof T];
+
+export type IDItem<T> = {
+    id: T;
+};
+
+
+
+/** Buffer이지만 ts에서 타입 구분 편의를 제공 */
+export interface WrappedBuffer extends Buffer {
+	/** 타입구분자. 항상 undefined일 것이다 */
+	_w_type?: string;
+}
+
+export type BufferSource = ArrayBufferView | ArrayBuffer | SharedArrayBuffer;
+export type BytesLike = BufferSource | string;
+
+
+/**
+ * base64 string에 내부 타입으로 WrappedBuffer를 보관한 형태
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Base64String<T extends Buffer> = string & {
+	/** 타입구분자. 항상 undefined일 것이다 */
+	_b_type?: T;
+}