diff --git a/deps.deno_ext.ts b/deps.deno_ext.ts
index 81bbfb1..9ae2302 100644
--- a/deps.deno_ext.ts
+++ b/deps.deno_ext.ts
@@ -1,5 +1,5 @@
-export {Logger, ConsoleHandler, FileHandler} from "https://deno.land/std@0.221.0/log/mod.ts";
-export {format} from "https://deno.land/std@0.221.0/datetime/mod.ts";
+export {Logger, ConsoleHandler, FileHandler} from "https://deno.land/std@0.223.0/log/mod.ts";
+export {format} from "https://deno.land/std@0.223.0/datetime/mod.ts";
 
 export {type Element, DOMParser} from "https://deno.land/x/deno_dom@v0.1.45/deno-dom-wasm.ts";
 
diff --git a/deps.pure_ext.ts b/deps.pure_ext.ts
index 6576fb1..8783d80 100644
--- a/deps.pure_ext.ts
+++ b/deps.pure_ext.ts
@@ -1,7 +1,7 @@
-// @deno-types="https://deno.land/std@0.221.0/csv/mod.ts"
-export {parse, stringify} from "https://esm.sh/gh/denoland/deno_std@0.221.0/csv/mod.ts?bundle&target=esnext";
-// @deno-types="https://deno.land/x/zipjs@v2.7.41/index.d.ts"
-export {ZipReader, ZipWriter, Uint8ArrayReader, Uint8ArrayWriter} from "https://esm.sh/gh/gildas-lormeau/zip.js@v2.7.41/index.js?bundle&target=esnext";
+// @deno-types="https://deno.land/std@0.223.0/csv/mod.ts"
+export {parse, stringify} from "https://esm.sh/gh/denoland/deno_std@0.223.0/csv/mod.ts?bundle&target=esnext";
+// @deno-types="https://deno.land/x/zipjs@v2.7.43/index.d.ts"
+export {ZipReader, ZipWriter, Uint8ArrayReader, Uint8ArrayWriter} from "https://esm.sh/gh/gildas-lormeau/zip.js@v2.7.43/index.js?bundle&target=esnext";
 
 // @deno-types="https://cdn.sheetjs.com/xlsx-0.20.2/package/types/index.d.ts"
 export {type WorkBook as RawWorkBook, type WorkSheet as RawWorkSheet, type CellObject as RawWorkCell, set_cptable, read as xlsxRead, write as xlsxWrite, utils as xlsxUtil} from "https://cdn.sheetjs.com/xlsx-0.20.2/package/xlsx.mjs";
diff --git a/deps.test.ts b/deps.test.ts
index 1d89a47..58e5545 100644
--- a/deps.test.ts
+++ b/deps.test.ts
@@ -1,7 +1,7 @@
-export {assertEquals} from "https://deno.land/std@0.221.0/assert/mod.ts";
-export {dirname, fromFileUrl} from "https://deno.land/std@0.221.0/path/mod.ts";
-export {exists} from "https://deno.land/std@0.221.0/fs/mod.ts";
-export {delay} from "https://deno.land/std@0.221.0/async/mod.ts";
+export {assertEquals} from "https://deno.land/std@0.223.0/assert/mod.ts";
+export {dirname, fromFileUrl} from "https://deno.land/std@0.223.0/path/mod.ts";
+export {exists} from "https://deno.land/std@0.223.0/fs/mod.ts";
+export {delay} from "https://deno.land/std@0.223.0/async/mod.ts";
 
 export {DOMParser} from "https://deno.land/x/deno_dom@v0.1.45/deno-dom-wasm.ts";
 
diff --git a/mod.full.ts b/mod.full.ts
index a7ac2ad..20cdae6 100644
--- a/mod.full.ts
+++ b/mod.full.ts
@@ -1,8 +1,9 @@
-export * from "./mod.ts";
+export * from "./mod.pure.full.ts";
 
-export * from "./src/pure_ext/csv.ts";
-export * from "./src/pure_ext/excel.ts";
-export * from "./src/pure_ext/zip.ts";
+export * from "./src/deno/json.ts";
+export * from "./src/deno/os.ts";
+export * from "./src/deno/path.ts";
+export * from "./src/deno/process.ts";
 
 export * from "./src/deno_ext/dom.ts";
 export * from "./src/deno_ext/log.ts";
diff --git a/mod.ts b/mod.ts
index 42867e6..985afb1 100644
--- a/mod.ts
+++ b/mod.ts
@@ -1,15 +1,4 @@
-export * from "./src/pure/base64.ts";
-export * from "./src/pure/byte.ts";
-export * from "./src/pure/crypto.ts";
-export * from "./src/pure/deep.ts";
-export * from "./src/pure/deflate.ts";
-export * from "./src/pure/fetch.ts";
-export * from "./src/pure/minipack.ts";
-export * from "./src/pure/primitive.ts";
-export * from "./src/pure/stream.ts";
-export * from "./src/pure/text.ts";
-export * from "./src/pure/time.ts";
-export * from "./src/pure/worker.ts";
+export * from "./mod.pure.ts";
 
 export * from "./src/deno/json.ts";
 export * from "./src/deno/os.ts";
diff --git a/src/deno/json.ts b/src/deno/json.ts
index 615a64c..4b065c8 100644
--- a/src/deno/json.ts
+++ b/src/deno/json.ts
@@ -30,7 +30,7 @@ export async function jsonWrite<T extends Opt<T>>(path:string, data:T):Promise<v
 * Argument default value also act as type definition.
 * @example
 * ```ts
-* import data from "./data.json" assert {type: "json"};
+* import data from "./data.json" with {type: "json"};
 * const json = await jsonLoad("./data.json", data);
 * ```
 */
diff --git a/src/deno/os.ts b/src/deno/os.ts
index eb05228..44a1ad8 100644
--- a/src/deno/os.ts
+++ b/src/deno/os.ts
@@ -5,4 +5,22 @@
 * const isWin = osWin;
 * ```
 */
-export const osWin:boolean = Deno.build.os === "windows";
\ No newline at end of file
+export const osWindows:boolean = Deno.build.os === "windows";
+
+/**
+* Are you running on Mac?
+* @example
+* ```ts
+* const isMac = osMac;
+* ```
+*/
+export const osMac:boolean = Deno.build.os === "darwin";
+
+/**
+* Are you running on Linux?
+* @example
+* ```ts
+* const isLinux = osLinux;
+* ```
+*/
+export const osLinux:boolean = Deno.build.os === "linux";
\ No newline at end of file
diff --git a/src/deno/path.ts b/src/deno/path.ts
index 696b86a..b4b18d2 100644
--- a/src/deno/path.ts
+++ b/src/deno/path.ts
@@ -1,14 +1,14 @@
-import {osWin} from "./os.ts";
+import {osWindows} from "./os.ts";
 
 /**
 * Convert from backslash to slash.
 * Useful for converting from Windows path to UNIX path.
 * @example
 * ```ts
-* const path = slashU("C:\\file");
+* const path = pathSepL("C:\\file");
 * ```
 */
-export function slashU(path:string):string{
+export function pathSepL(path:string):string{
     return path.replace(/\\/g, "/");
 }
 
@@ -17,10 +17,10 @@ export function slashU(path:string):string{
 * Useful for converting from UNIX path to Windows path.
 * @example
 * ```ts
-* const path = slashW("C:/file");
+* const path = pathSepW("C:/file");
 * ```
 */
-export function slashW(path:string):string{
+export function pathSepW(path:string):string{
     return path.replace(/\//g, "\\");
 }
 
@@ -29,11 +29,11 @@ export function slashW(path:string):string{
 * `/tmp` for UNIX and `C:/Windows/Temp` for Windows.
 * @example
 * ```ts
-* const path = tmpPath();
+* const path = pathTmp();
 * ```
 */
-export function tmpPath():string{
-    return osWin ? "C:/Windows/Temp" : "/tmp";
+export function pathTmp():string{
+    return osWindows ? "C:/Windows/Temp" : "/tmp";
 }
 
 /**
@@ -41,11 +41,11 @@ export function tmpPath():string{
 * `/var` for UNIX and `C:/ProgramData` for Windows.
 * @example
 * ```ts
-* const path = dataPath();
+* const path = pathVar();
 * ```
 */
-export function dataPath():string{
-    return osWin ? "C:/ProgramData" : "/var";
+export function pathVar():string{
+    return osWindows ? "C:/ProgramData" : "/var";
 }
 
 /**
@@ -53,11 +53,11 @@ export function dataPath():string{
 * `~/.config` for UNIX and `~/AppData/Roaming` for Windows.
 * @example
 * ```ts
-* const path = configPath();
+* const path = pathConfig();
 * ```
 */
-export function configPath():string{
-    return `${homePath()}/${osWin ? "AppData/Roaming" : ".config"}`;
+export function pathConfig():string{
+    return `${pathHome()}/${osWindows ? "AppData/Roaming" : ".config"}`;
 }
 
 /**
@@ -65,25 +65,24 @@ export function configPath():string{
 * `${HOME}` for UNIX and `%USERPROFILE%` for Windows.
 * @example
 * ```ts
-* const path = homePath();
+* const path = pathHome();
 * ```
 */
-export function homePath():string{
+export function pathHome():string{
     const {HOME, USERPROFILE} = Deno.env.toObject();
 
-    return osWin ? slashU(USERPROFILE) : HOME;
+    return osWindows ? pathSepL(USERPROFILE) : HOME;
 }
 
 /**
 * Directory of `Deno.mainModule`.
 * @example
 * ```ts
-* const path = mainPath();
+* const path = pathMain();
 * ```
 */
-export function mainPath():string{
-    const {protocol, origin, pathname} = new URL(Deno.mainModule);
-    const path = pathname.replace(/[^/]*$/, "");
+export function pathMain():string{
+    const directory = new URL(Deno.mainModule).pathname.replace(/[^/]*$/, "");
 
-    return protocol === "file:" ? osWin ? path.replace(/^\//, "") : path : `${origin}${path}`;
+    return osWindows ? directory.replace(/^\//, "") : directory;
 }
\ No newline at end of file
diff --git a/src/deno/process.ts b/src/deno/process.ts
index e84a689..86f00b5 100644
--- a/src/deno/process.ts
+++ b/src/deno/process.ts
@@ -2,10 +2,10 @@
 * Run command as subprocess.
 * @example
 * ```ts
-* const success = await runCommand("echo", "foobar");
+* const success = await processRun("echo", "foobar");
 * ```
 */
-export async function runCommand(...commands:string[]):Promise<boolean>{
+export async function processRun(...commands:string[]):Promise<boolean>{
     const {success} = await new Deno.Command(commands.shift() ?? "", {
         args: commands,
         stdin: "null",
diff --git a/src/deno_ext/dom.ts b/src/deno_ext/dom.ts
index 3d1724c..6bba39e 100644
--- a/src/deno_ext/dom.ts
+++ b/src/deno_ext/dom.ts
@@ -8,17 +8,13 @@ function getValue(element?:Element){
     return element?.getAttribute("value") ?? "";
 }
 
-function getContent({textContent}:Element){
-    return textContent;
-}
-
 function extractValue(element?:Element){
     switch(element?.tagName){
         case "SELECT": return getValue(selectedElement(element.getElementsByTagName("option"), "selected"));
         case "DATALIST": return getValue(selectedElement(element.getElementsByTagName("option"), "selected"));
         case "OPTION": return getValue(element);
         case "INPUT": return getValue(element);
-        case "TEXTAREA": return getContent(element);
+        case "TEXTAREA": return element.textContent;
         default: return "";
     }
 }
@@ -28,10 +24,10 @@ function extractValue(element?:Element){
 * @see https://deno.land/x/deno_dom
 * @example
 * ```ts
-* const dom = parseDOM("<div>foo</div>");
+* const dom = domDecode("<div>foo</div>");
 * ```
 */
-export function parseDOM(html:string):Element{
+export function domDecode(html:string):Element{
     const element = new DOMParser().parseFromString(html, "text/html")?.documentElement;
 
     if(!element){
@@ -45,11 +41,11 @@ export function parseDOM(html:string):Element{
 * Find all `input` `textarea` elements with `id` attribute and convert them to key-value record.
 * @example
 * ```ts
-* const dom = parseDOM("<input id='foo'><textarea id='bar'></textarea>");
-* const result = collectInputById(dom);
+* const dom = domDecode("<input id='foo'>");
+* const result = domValuesPerId(dom);
 * ```
 */
-export function collectInputById(element:Element):Record<string, string>{
+export function domValuesPerId(element:Element):Record<string, string>{
     const records:Record<string, string> = {};
 
     for(const input of element.getElementsByTagName("INPUT")){
@@ -65,35 +61,35 @@ export function collectInputById(element:Element):Record<string, string>{
             continue;
         }
 
-        records[textarea.id] = getContent(textarea);
+        records[textarea.id] = textarea.textContent;
     }
 
     return structuredClone(records);
 }
 
 /**
-* Find all elements with `name` attribute.
+* Get value by `id` search.
+* `.value` for `<input>`, `.textContent` for `<textarea>` and `.value` of `.selected` for `<select>` `<dataset>`.
 * @example
-* ```ts
-* const dom = parseDOM("<input name='foo'>");
-* const result = getElementsByName(dom, "foo");
+* ```ts\
+* const dom = domDecode("<input id='foo'>");
+* const result = domValueById(dom, "foo");
 * ```
 */
-export function getElementsByName(element:Element, name:string):Element[]{
-    return element.getElementsByTagName("*").filter(v => v.getAttribute("name") === name);
+export function domValueById(element:Element, id:string):string{
+    return extractValue(element.getElementById(id) ?? undefined);
 }
 
 /**
-* Get value by `id` search.
-* `.value` for `<input>`, `.textContent` for `<textarea>` and `.value` of `.selected` for `<select>` `<dataset>`.
+* Find all elements with `name` attribute.
 * @example
-* ```ts\
-* const dom = parseDOM("<input id='foo'>");
-* const result = getValueById(dom, "foo");
+* ```ts
+* const dom = domDecode("<input name='foo'>");
+* const result = domElementsByName(dom, "foo");
 * ```
 */
-export function getValueById(element:Element, id:string):string{
-    return extractValue(element.getElementById(id) ?? undefined);
+export function domElementsByName(element:Element, name:string):Element[]{
+    return element.getElementsByTagName("*").filter(v => v.getAttribute("name") === name);
 }
 
 /**
@@ -101,24 +97,24 @@ export function getValueById(element:Element, id:string):string{
 * `.value` for `<input>`, `.textContent` for `<textarea>` and `.value` of `.selected` for `<select>` `<dataset>`.
 * @example
 * ```ts
-* const dom = parseDOM("<input name='foo'>");
-* const result = getValuesByName(dom, "foo");
+* const dom = domDecode("<input name='foo'>");
+* const result = domValuesByName(dom, "foo");
 * ```
 */
-export function getValuesByName(element:Element, name:string):string[]{
-    return getElementsByName(element, name).map(v => extractValue(v));
+export function domValuesByName(element:Element, name:string):string[]{
+    return domElementsByName(element, name).map(v => extractValue(v));
 }
 
 /**
-* Gets value of `.checked` in group of radio buttons.
+* Get value of `.checked` in group of radio buttons.
 * @example
 * ```ts
-* const dom = parseDOM("<input type='radio' name='foo' value='1' checked><input type='radio' name='foo' value='2'>");
-* const result = getValueByRadioActive(dom, "foo");
+* const dom = domDecode("<input type='radio' name='foo' value='1' checked><input type='radio' name='foo' value='2'>");
+* const result = domValueByRadioActive(dom, "foo");
 * ```
 */
-export function getValueByRadioActive(element:Element, name:string):string{
-    const elements = getElementsByName(element, name);
+export function domValueByRadioActive(element:Element, name:string):string{
+    const elements = domElementsByName(element, name);
 
     if(elements.some(v => v.tagName !== "INPUT" || v.getAttribute("type") !== "radio")){
         return "";
diff --git a/src/pure/base64.ts b/src/pure/base64.ts
index 1699364..822fb25 100644
--- a/src/pure/base64.ts
+++ b/src/pure/base64.ts
@@ -3,36 +3,36 @@
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const encode = b64Encode(bin);
-* const decode = b64Decode(encode);
+* const encode = base64Encode(bin);
+* const decode = base64Decode(encode);
 * ```
 */
-export function b64Encode(data:Uint8Array):string{
+export function base64Encode(data:Uint8Array):string{
     return btoa([...data].map(v => String.fromCharCode(v)).join(""));
 }
 
 /**
-* Convert from base64 encoded string to binary.
+* Convert from binary to base64 encoded DataURL.
+* Default MIME type is `application/octet-stream`.
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const encode = b64Encode(bin);
-* const decode = b64Decode(encode);
+* const data = base64EncodeDataURL(bin);
 * ```
 */
-export function b64Decode(data:string):Uint8Array{
-    return new Uint8Array([...atob(data)].map(v => v.charCodeAt(0)));
+export function base64EncodeDataURL(data:Uint8Array, type?:string):string{
+    return `data:${type ?? "application/octet-stream"};base64,${base64Encode(data)}`;
 }
 
 /**
-* Convert from binary to base64 encoded DataURL.
-* Default MIME type is `application/octet-stream`.
+* Convert from base64 encoded string to binary.
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const data = b64DataURL(bin);
+* const encode = base64Encode(bin);
+* const decode = base64Decode(encode);
 * ```
 */
-export function b64DataURL(data:Uint8Array, type?:string):string{
-    return `data:${type ?? "application/octet-stream"};base64,${b64Encode(data)}`;
+export function base64Decode(data:string):Uint8Array{
+    return new Uint8Array([...atob(data)].map(v => v.charCodeAt(0)));
 }
\ No newline at end of file
diff --git a/src/pure/byte.ts b/src/pure/byte.ts
index 23daaae..950ff18 100644
--- a/src/pure/byte.ts
+++ b/src/pure/byte.ts
@@ -1,5 +1,5 @@
 /**
-* Concat multiple buffer sources into single binary.
+* Concat multiple sources into single binary.
 * @example
 * ```ts
 * const byte = byteConcat(new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6]));
diff --git a/src/pure/crypto.ts b/src/pure/crypto.ts
index 15debea..653fb2c 100644
--- a/src/pure/crypto.ts
+++ b/src/pure/crypto.ts
@@ -10,17 +10,17 @@ const AES_BIT = 128;
 const FORMAT_PUB = "spki";
 const FORMAT_PRI = "pkcs8";
 
-const CURVE_ECDH = Object.freeze({
+const CURVE_ECDH = Object.freeze<EcKeyAlgorithm>({
     name: "ECDH",
     namedCurve: "P-256"
 });
 
-const CURVE_ECDSA = Object.freeze({
+const CURVE_ECDSA = Object.freeze<EcKeyAlgorithm>({
     name: "ECDSA",
     namedCurve: "P-256"
 });
 
-const MAC_ECDSA = Object.freeze({
+const MAC_ECDSA = Object.freeze<EcdsaParams>({
     name: "ECDSA",
     hash: "SHA-256"
 });
@@ -48,10 +48,10 @@ async function deriveKey({publicKey, privateKey}:PortableCryptoKeyPair){
 * Generate random binary with any number of bytes.
 * @example
 * ```ts
-* const random = generateRandom(16);
+* const random = cryptoRandom(16);
 * ```
 */
-export function generateRandom(n:number):Uint8Array{
+export function cryptoRandom(n:number):Uint8Array{
     return crypto.getRandomValues(new Uint8Array(n));
 }
 
@@ -61,10 +61,10 @@ export function generateRandom(n:number):Uint8Array{
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const hash = await deriveHash(bin);
+* const hash = await cryptoHash(bin);
 * ```
 */
-export async function deriveHash(data:Uint8Array, sha?:`SHA-${256 | 384 | 512}`):Promise<Uint8Array>{
+export async function cryptoHash(data:Uint8Array, sha?:`SHA-${256 | 384 | 512}`):Promise<Uint8Array>{
     return new Uint8Array(await crypto.subtle.digest(sha ?? "SHA-256", data));
 }
 
@@ -73,11 +73,11 @@ export async function deriveHash(data:Uint8Array, sha?:`SHA-${256 | 384 | 512}`)
 * Curve algorithm is "NIST P-256".
 * @example
 * ```ts
-* const k1 = await pkGenerateECDH();
-* const k2 = await pkGenerateECDH();
+* const k1 = await cryptoGenerateEncryptKey();
+* const k2 = await cryptoGenerateEncryptKey();
 * ```
 */
-export async function pkGenerateECDH():Promise<PortableCryptoKeyPair>{
+export async function cryptoGenerateEncryptKey():Promise<PortableCryptoKeyPair>{
     return await generateKey(CURVE_ECDH, ["deriveKey"]);
 }
 
@@ -86,10 +86,10 @@ export async function pkGenerateECDH():Promise<PortableCryptoKeyPair>{
 * Curve algorithm is "NIST P-256".
 * @example
 * ```ts
-* const {publicKey, privateKey} = await pkGenerateECDSA();
+* const {publicKey, privateKey} = await cryptoGenerateSignKey();
 * ```
 */
-export async function pkGenerateECDSA():Promise<PortableCryptoKeyPair>{
+export async function cryptoGenerateSignKey():Promise<PortableCryptoKeyPair>{
     return await generateKey(CURVE_ECDSA, ["sign", "verify"]);
 }
 
@@ -100,22 +100,22 @@ export async function pkGenerateECDSA():Promise<PortableCryptoKeyPair>{
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const k1 = await pkGenerateECDH();
-* const k2 = await pkGenerateECDH();
-* const cipher = await pkEncrypt(bin, {
+* const k1 = await cryptoGenerateEncryptKey();
+* const k2 = await cryptoGenerateEncryptKey();
+* const cipher = await cryptoEncrypt(bin, {
 *     publicKey: k1.publicKey,
 *     privateKey: k2.privateKey
 * });
-* const decrypt = await pkDecrypt(cipher, {
+* const decrypt = await cryptoDecrypt(cipher, {
 *     publicKey: k2.publicKey,
 *     privateKey: k1.privateKey
 * });
 * ```
 */
-export async function pkEncrypt(data:Uint8Array, {publicKey, privateKey}:PortableCryptoKeyPair):Promise<Uint8Array>{
+export async function cryptoEncrypt(data:Uint8Array, {publicKey, privateKey}:PortableCryptoKeyPair):Promise<Uint8Array>{
     const aes = {
         name: AES_MODE,
-        iv: generateRandom(12)
+        iv: cryptoRandom(12)
     };
 
     return byteConcat(aes.iv, await crypto.subtle.encrypt(aes, await deriveKey({publicKey, privateKey}), data));
@@ -128,19 +128,19 @@ export async function pkEncrypt(data:Uint8Array, {publicKey, privateKey}:Portabl
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const k1 = await pkGenerateECDH();
-* const k2 = await pkGenerateECDH();
-* const cipher = await pkEncrypt(bin, {
+* const k1 = await cryptoGenerateEncryptKey();
+* const k2 = await cryptoGenerateEncryptKey();
+* const cipher = await cryptoEncrypt(bin, {
 *     publicKey: k1.publicKey,
 *     privateKey: k2.privateKey
 * });
-* const decrypt = await pkDecrypt(cipher, {
+* const decrypt = await cryptoDecrypt(cipher, {
 *     publicKey: k2.publicKey,
 *     privateKey: k1.privateKey
 * });
 * ```
 */
-export async function pkDecrypt(data:Uint8Array, {publicKey, privateKey}:PortableCryptoKeyPair):Promise<Uint8Array>{
+export async function cryptoDecrypt(data:Uint8Array, {publicKey, privateKey}:PortableCryptoKeyPair):Promise<Uint8Array>{
     const aes = {
         name: AES_MODE,
         iv: data.subarray(0, 12)
@@ -154,12 +154,12 @@ export async function pkDecrypt(data:Uint8Array, {publicKey, privateKey}:Portabl
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const {publicKey, privateKey} = await pkGenerateECDSA();
-* const sign = await pkSign(bin, privateKey);
-* const verify = await pkVerify(bin, publicKey, sign);
+* const {publicKey, privateKey} = await cryptoGenerateSignKey();
+* const sign = await cryptoSign(bin, privateKey);
+* const verify = await cryptoVerify(bin, publicKey, sign);
 * ```
 */
-export async function pkSign(data:Uint8Array, key:Uint8Array):Promise<Uint8Array>{
+export async function cryptoSign(data:Uint8Array, key:Uint8Array):Promise<Uint8Array>{
     return new Uint8Array(await crypto.subtle.sign(MAC_ECDSA, await crypto.subtle.importKey(FORMAT_PRI, key, CURVE_ECDSA, false, ["sign"]), data));
 }
 
@@ -168,11 +168,11 @@ export async function pkSign(data:Uint8Array, key:Uint8Array):Promise<Uint8Array
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const {publicKey, privateKey} = await pkGenerateECDSA();
-* const sign = await pkSign(bin, privateKey);
-* const verify = await pkVerify(bin, publicKey, sign);
+* const {publicKey, privateKey} = await cryptoGenerateSignKey();
+* const sign = await cryptoSign(bin, privateKey);
+* const verify = await cryptoVerify(bin, publicKey, sign);
 * ```
 */
-export async function pkVerify(data:Uint8Array, key:Uint8Array, sign:Uint8Array):Promise<boolean>{
+export async function cryptoVerify(data:Uint8Array, key:Uint8Array, sign:Uint8Array):Promise<boolean>{
     return await crypto.subtle.verify(MAC_ECDSA, await crypto.subtle.importKey(FORMAT_PUB, key, CURVE_ECDSA, false, ["verify"]), sign, data);
 }
\ No newline at end of file
diff --git a/src/pure/deep.ts b/src/pure/deep.ts
index c68f4e3..9346ccd 100644
--- a/src/pure/deep.ts
+++ b/src/pure/deep.ts
@@ -1,5 +1,5 @@
 /**
-* Make interfaces acceptable in `Record` type arguments.
+* Make interface acceptable in `Record` type argument.
 */
 export type Opt<T> = Partial<Record<keyof T, unknown>>;
 
@@ -8,7 +8,7 @@ function hasObject(data:Record<string | number | symbol, unknown>, key:string){
 }
 
 /**
-* Applies `Object.freeze()` recursively.
+* Apply `Object.freeze()` recursive.
 * @example
 * ```ts
 * const freeze = deepFreeze({
@@ -18,7 +18,7 @@ function hasObject(data:Record<string | number | symbol, unknown>, key:string){
 * });
 * ```
 */
-export function deepFreeze<T extends Opt<T>>(data:T):T{
+export function deepFreeze<T extends Opt<T>>(data:T):Readonly<T>{
     Object.freeze(data);
 
     for(const key in data){
@@ -31,7 +31,7 @@ export function deepFreeze<T extends Opt<T>>(data:T):T{
 }
 
 /**
-* Applies `Object.seal()` recursively.
+* Apply `Object.seal()` recursive.
 * @example
 * ```ts
 * const seal = deepSeal({
diff --git a/src/pure/deflate.ts b/src/pure/deflate.ts
index ac0a376..a8a7175 100644
--- a/src/pure/deflate.ts
+++ b/src/pure/deflate.ts
@@ -2,7 +2,7 @@ import {streamEncode, streamDecode} from "./stream.ts";
 
 type CompressCodec = "gzip" | "deflate" | "deflate-raw";
 
-const COMPRESS_CODEC = "deflate-raw";
+const COMPRESS_CODEC:CompressCodec = "deflate-raw";
 
 /**
 * Compress binary with DEFLATE format.
diff --git a/src/pure/fetch.ts b/src/pure/fetch.ts
index b6cc902..5539579 100644
--- a/src/pure/fetch.ts
+++ b/src/pure/fetch.ts
@@ -1,4 +1,4 @@
-import {b64Encode} from "./base64.ts";
+import {base64Encode} from "./base64.ts";
 
 interface ResponseType{
     "text": string;
@@ -56,7 +56,7 @@ export async function fetchExtend<T extends keyof ResponseType>(path:string, typ
 
     switch(type){
         case "text": return <ResponseType[T]>await response.text();
-        case "base64": return <ResponseType[T]>b64Encode(new Uint8Array(await response.arrayBuffer()));
+        case "base64": return <ResponseType[T]>base64Encode(new Uint8Array(await response.arrayBuffer()));
         case "json": return <ResponseType[T]>await response.json();
         case "form": return <ResponseType[T]>await response.formData();
         case "byte": return <ResponseType[T]>new Uint8Array(await response.arrayBuffer());
diff --git a/src/pure/minipack.ts b/src/pure/minipack.ts
index 7b1d236..726d6e7 100644
--- a/src/pure/minipack.ts
+++ b/src/pure/minipack.ts
@@ -1,10 +1,10 @@
-import {u8Encode, u8Decode} from "./text.ts";
+import {textEncode, textDecode} from "./text.ts";
 
 const MINIPACK_NAME = 1;
 const MINIPACK_BODY = 4;
 
 /**
-* Simple name and data pair.
+* Simple name and body pair.
 */
 export interface DataMap{
     name: string;
@@ -12,7 +12,7 @@ export interface DataMap{
 }
 
 /**
-* Concatenate files with "minipack" format.
+* Concat files with "minipack" format.
 * @see https://deno.land/x/simple_utility#minipack
 * @example
 * ```ts
@@ -25,11 +25,11 @@ export interface DataMap{
 * ```
 */
 export function minipackEncode(files:DataMap[]):Uint8Array{
-    const archive = new Uint8Array(files.reduce((size, {name, body}) => size + MINIPACK_NAME + MINIPACK_BODY + u8Encode(name).byteLength + body.byteLength, 0));
+    const archive = new Uint8Array(files.reduce((size, {name, body}) => size + MINIPACK_NAME + MINIPACK_BODY + textEncode(name).byteLength + body.byteLength, 0));
 
     let i = 0;
     for(const {name, body} of files){
-        const u8name = u8Encode(name);
+        const u8name = textEncode(name);
 
         new DataView(archive.buffer, i).setUint8(0, u8name.byteLength);
         i += MINIPACK_NAME;
@@ -71,7 +71,7 @@ export function minipackDecode(archive:Uint8Array):DataMap[]{
         i += MINIPACK_BODY;
 
         files.push({
-            name: u8Decode(archive.subarray(i, i += ns)),
+            name: textDecode(archive.subarray(i, i += ns)),
             body: archive.slice(i, i += bs)
         });
     }
diff --git a/src/pure/text.ts b/src/pure/text.ts
index f19ff20..68c43fa 100644
--- a/src/pure/text.ts
+++ b/src/pure/text.ts
@@ -3,11 +3,11 @@
 * @example
 * ```ts
 * const text = "HelloWorld!";
-* const encode = u8Encode(text);
-* const decode = u8Decode(encode);
+* const encode = textEncode(text);
+* const decode = textDecode(encode);
 * ```
 */
-export function u8Encode(data:string):Uint8Array{
+export function textEncode(data:string):Uint8Array{
     return new TextEncoder().encode(data);
 }
 
@@ -16,11 +16,11 @@ export function u8Encode(data:string):Uint8Array{
 * @example
 * ```ts
 * const text = "HelloWorld!";
-* const encode = u8Encode(text);
-* const decode = u8Decode(encode);
+* const encode = textEncode(text);
+* const decode = textDecode(encode);
 * ```
 */
-export function u8Decode(data:Uint8Array):string{
+export function textDecode(data:Uint8Array):string{
     return new TextDecoder().decode(data);
 }
 
@@ -30,10 +30,10 @@ export function u8Decode(data:Uint8Array):string{
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const decode = textDecode(bin);
+* const decode = textDecodeAny(bin);
 * ```
 */
-export function textDecode(data:Uint8Array, codec?:string):string{
+export function textDecodeAny(data:Uint8Array, codec?:string):string{
     return new TextDecoder(codec ?? "shift-jis").decode(data);
 }
 
@@ -42,12 +42,12 @@ export function textDecode(data:Uint8Array, codec?:string):string{
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const encode = hexEncode(bin);
-* const decode = hexDecode(encode);
+* const encode = textHexEncode(bin);
+* const decode = textHexDecode(encode);
 * ```
 */
-export function hexEncode(data:Uint8Array):string{
-    return [...data].map(v => pad0(v, 2, 16)).join("");
+export function textHexEncode(data:Uint8Array):string{
+    return [...data].map(v => textPadZero(v, 2, 16)).join("");
 }
 
 /**
@@ -55,22 +55,22 @@ export function hexEncode(data:Uint8Array):string{
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const encode = hexEncode(bin);
-* const decode = hexDecode(encode);
+* const encode = textHexEncode(bin);
+* const decode = textHexDecode(encode);
 * ```
 */
-export function hexDecode(data:string):Uint8Array{
+export function textHexDecode(data:string):Uint8Array{
     return new Uint8Array(data.match(/[0-9a-fA-F]{2}/g)?.map(v => Number(`0x${v}`)) ?? []);
 }
 
 /**
-* Trim head and tail blank, remove CR and consecutive space (tab, LF) to single space (tab, LF).
+* Trim head and tail blank, remove CR and consecutive space, tab, LF to single space, tab, LF.
 * @example
 * ```ts
-* const format = trimExtend("  Lorem ipsum\r dolor   sit  \r\r amet. ");
+* const format = textPurgeSuperfluous("  Lorem ipsum\r dolor   sit  \r\r amet. ");
 * ```
 */
-export function trimExtend(data:string):string{
+export function textPurgeSuperfluous(data:string):string{
     return data.trim().replace(/\r/g, "").replace(/ +/g, " ").replace(/\t+/g, "\t").replace(/\n+/g, "\n").replace(/^ /mg, "").replace(/ $/mg, "");
 }
 
@@ -78,10 +78,10 @@ export function trimExtend(data:string):string{
 * Convert half-width string (ex: Japanese Kana) to full-width and full-width alphanumeric symbols to half-width.
 * @example
 * ```ts
-* const format = fixWidth("１＋１＝２");
+* const format = textFixWidth("１＋１＝２");
 * ```
 */
-export function fixWidth(data:string):string{
+export function textFixWidth(data:string):string{
     return Object.entries({
         "ｳﾞ": "ヴ",
         "ｶﾞ": "ガ", "ｷﾞ": "ギ", "ｸﾞ": "グ", "ｹﾞ": "ゲ", "ｺﾞ": "ゴ",
@@ -114,14 +114,14 @@ export function fixWidth(data:string):string{
 }
 
 /**
-* Clean up text with `fixWidth()` and `trimExtend()`.
+* Combined `textFixWidth()` and `textPurgeSuperfluous()`.
 * @example
 * ```ts
-* const format = cleanText("１  ＋  １  ＝  ２  ");
+* const format = textGetReady("１  ＋  １  ＝  ２  ");
 * ```
 */
-export function cleanText(data:string):string{
-    return trimExtend(fixWidth(data));
+export function textGetReady(data:string):string{
+    return textPurgeSuperfluous(textFixWidth(data));
 }
 
 /**
@@ -129,10 +129,10 @@ export function cleanText(data:string):string{
 * Useful for calculate number of characters with string contains emoji.
 * @example
 * ```ts
-* const characters = accurateSegment("😀😃😄😁😆😅😂🤣");
+* const emojis = textSplitBySegment("😀😃😄😁😆😅😂🤣");
 * ```
 */
-export function accurateSegment(data:string):string[]{
+export function textSplitBySegment(data:string):string[]{
     return [...new Intl.Segmenter().segment(data)].map(({segment}) => segment);
 }
 
@@ -141,9 +141,9 @@ export function accurateSegment(data:string):string[]{
 * Output is 2 digits by default.
 * @example
 * ```ts
-* const pad = pad0(8);
+* const pad = textPadZero(8);
 * ```
 */
-export function pad0(data:number, digit?:number, radix?:number):string{
+export function textPadZero(data:number, digit?:number, radix?:number):string{
     return data.toString(radix).toUpperCase().padStart(digit ?? 2, "0");
 }
\ No newline at end of file
diff --git a/src/pure/time.ts b/src/pure/time.ts
index e86e1c8..801cb4a 100644
--- a/src/pure/time.ts
+++ b/src/pure/time.ts
@@ -1,72 +1,71 @@
-import {pad0} from "./text.ts";
+import {textPadZero} from "./text.ts";
 
-/**
-* UNIX time in seconds.
-* If no args will be current time.
-* Note that in seconds not milliseconds.
-* @example
-* ```ts
-* const time = utEncode();
-* const date = utDecode(time);
-* ```
-*/
-export function utEncode(date?:Date):number{
-    return Math.floor((date ?? new Date()).getTime() / 1000);
+function dateFormat(date:string){
+    const [y, m, d, h, mi, s] = date.split(/[/ :TZ_.-]/i).map(v => Number(v));
+
+    return new Date(y, (m ?? 1) - 1, d ?? 1, h ?? 0, mi ?? 0, s ?? 0);
 }
 
 /**
-* `Date` from UNIX time.
-* Note that in seconds not milliseconds.
+* Wait for specified time.
+* Return actual elapsed wait time.
 * @example
 * ```ts
-* const time = utEncode();
-* const date = utDecode(time);
+* await delay(1000);
 * ```
 */
-export function utDecode(time:number):Date{
-    return new Date(time * 1000);
+export async function delay(time:number):Promise<number>{
+    const t0 = performance.now();
+    await new Promise<void>(done => setTimeout(done, time));
+    const t1 = performance.now();
+
+    return Math.ceil(t1 - t0);
 }
 
 /**
-* Convert from formatted datetime string such as ISO8601 to UNIX time in seconds.
+* Convert from `Date` or formatted datetime string to UNIXTIME.
+* If no args will be current time.
+* Note that in seconds not milliseconds.
 * @example
 * ```ts
-* const time = utParse("2023-05-18T08:31:32.292Z");
+* const time = timeEncode();
+* const date = timeDecode(time);
 * ```
 */
-export function utParse(ds:string):number{
-    const [y, m, d, h, mi, s] = ds.split(/[/ :TZ_.-]/i).map(v => Number(v));
-
-    return utEncode(new Date(y, (m ?? 1) - 1, d ?? 1, h ?? 0, mi ?? 0, s ?? 0));
+export function timeEncode(dt?:Date | string):number{
+    return Math.floor((dt instanceof Date ? dt : typeof dt === "string" ? dateFormat(dt) : new Date()).getTime() / 1000);
 }
 
 /**
-* Wait for specified time.
-* Return actual elapsed wait time.
+* Convert from UNIXTIME or formatted datetime string to `Date`.
+* If no args will be current time.
+* Note that in seconds not milliseconds.
 * @example
 * ```ts
-* await delay(1000);
+* const time = timeEncode();
+* const date = timeDecode(time);
 * ```
 */
-export async function delay(time:number):Promise<number>{
-    const t0 = performance.now();
-    await new Promise<void>(done => setTimeout(done, time));
-    const t1 = performance.now();
-
-    return Math.ceil(t1 - t0);
+export function timeDecode(dt?:number | string):Date{
+    switch(typeof dt){
+        case "string": return dateFormat(dt);
+        case "number": return new Date(dt * 1000);
+        default: return new Date();
+    }
 }
 
 /**
-* Generate serialized string from current or any `Date` to "yyyyMMddhhmmss".
+* Serialize from `Date` or UNIXTIME or formatted datetime string to "yyyyMMddhhmmss".
+* If no args will be current time.
 * @example
 * ```ts
-* const format = dtSerial();
+* const format = timeFormatSerialize();
 * ```
 */
-export function dtSerial(date?:Date, split?:boolean):string{
-    const d = date ?? new Date();
+export function timeFormatSerialize(dt?:Date | number | string, split?:boolean):string{
     const ss = split ? "/" : "";
     const sc = split ? ":" : "";
+    const date = dt instanceof Date ? dt : timeDecode(dt);
 
-    return `${d.getFullYear()}${ss}${pad0(d.getMonth() + 1)}${ss}${pad0(d.getDate())}${split ? " " : ""}${pad0(d.getHours())}${sc}${pad0(d.getMinutes())}${sc}${pad0(d.getSeconds())}`;
+    return `${date.getFullYear()}${ss}${textPadZero(date.getMonth() + 1)}${ss}${textPadZero(date.getDate())}${split ? " " : ""}${textPadZero(date.getHours())}${sc}${textPadZero(date.getMinutes())}${sc}${textPadZero(date.getSeconds())}`;
 }
\ No newline at end of file
diff --git a/src/pure/worker.ts b/src/pure/worker.ts
index f978f6a..5447eaa 100644
--- a/src/pure/worker.ts
+++ b/src/pure/worker.ts
@@ -1,5 +1,5 @@
-import {b64DataURL} from "./base64.ts";
-import {u8Encode} from "./text.ts";
+import {base64EncodeDataURL} from "./base64.ts";
+import {textEncode} from "./text.ts";
 
 interface TaskMessage<T extends unknown>{
     message: T;
@@ -22,7 +22,7 @@ export type TaskContext<T extends unknown, K extends unknown> = (message:T, tran
 * `import` can only use "syntax", not "declaration".
 * @example
 * ```ts
-* const task = createTask<number, number>(async(data)=>{
+* const task = workerTask<number, number>(async(data)=>{
 *     const {delay} = await import("https://deno.land/std/async/mod.ts");
 *     await delay(data);
 *     return {
@@ -33,7 +33,7 @@ export type TaskContext<T extends unknown, K extends unknown> = (message:T, tran
 * const result2 = await task(20);
 * ```
 */
-export function createTask<T extends unknown, K extends unknown>(task:TaskAction<T, K>):TaskContext<T, K>{
+export function workerTask<T extends unknown, K extends unknown>(task:TaskAction<T, K>):TaskContext<T, K>{
     const script = /*js*/`
         globalThis.onmessage = async({data})=>{
             const {message, transfers} = await(${task.toString()})(data);
@@ -45,7 +45,7 @@ export function createTask<T extends unknown, K extends unknown>(task:TaskAction
 
     return (message, transfers)=>{
         return new Promise<K>((res, rej)=>{
-            const worker = new Worker(b64DataURL(u8Encode(script), "text/javascript"), {
+            const worker = new Worker(base64EncodeDataURL(textEncode(script), "text/javascript"), {
                 type: "module"
             });
 
diff --git a/src/pure_ext/excel.ts b/src/pure_ext/excel.ts
index c2559c0..41570bc 100644
--- a/src/pure_ext/excel.ts
+++ b/src/pure_ext/excel.ts
@@ -1,5 +1,5 @@
 import {type RawWorkBook, type RawWorkSheet, type RawWorkCell, xlsxcp, set_cptable, xlsxRead, xlsxWrite, xlsxUtil} from "../../deps.pure_ext.ts";
-import {dtSerial} from "../pure/time.ts";
+import {timeFormatSerialize} from "../pure/time.ts";
 
 export type {RawWorkBook, RawWorkSheet, RawWorkCell};
 
@@ -116,7 +116,7 @@ export function excelDecode(data:Uint8Array, cp?:number, pw?:string):Record<stri
                 }
                 else if(column.v instanceof Date){
                     column.v.setMinutes(new Date().getTimezoneOffset());
-                    columns.push(dtSerial(column.v, true));
+                    columns.push(timeFormatSerialize(column.v, true));
                 }
                 else{
                     columns.push(`${column.v}`);
diff --git a/src/pure_ext/zip.ts b/src/pure_ext/zip.ts
index 7d2207b..5fc3308 100644
--- a/src/pure_ext/zip.ts
+++ b/src/pure_ext/zip.ts
@@ -11,6 +11,7 @@ import {type DataMap} from "../pure/minipack.ts";
 *     body: await Deno.readFile("./foo.txt")
 * }];
 * const zip = await zipEncode(files);
+* const files = await zipDecode(zip);
 * ```
 */
 export async function zipEncode(files:DataMap[], pw?:string, weak?:boolean):Promise<Uint8Array>{
@@ -33,7 +34,11 @@ export async function zipEncode(files:DataMap[], pw?:string, weak?:boolean):Prom
 * @see https://deno.land/x/zipjs
 * @example
 * ```ts
-* const zip = await Deno.readFile("./foo.zip");
+* const files = [{
+*     name: "foo.txt",
+*     body: await Deno.readFile("./foo.txt")
+* }];
+* const zip = await zipEncode(files);
 * const files = await zipDecode(zip);
 * ```
 */
diff --git a/test/deno/os.test.ts b/test/deno/os.test.ts
index d93f8b6..96d7735 100644
--- a/test/deno/os.test.ts
+++ b/test/deno/os.test.ts
@@ -1,18 +1,32 @@
 import {assertEquals} from "../../deps.test.ts";
-import {osWin} from "../../src/deno/os.ts";
+import {osWindows, osMac, osLinux} from "../../src/deno/os.ts";
 
 Deno.test({
     ignore: Deno.build.os !== "windows",
-    name: "Platform: Windows",
+    name: "OS: Windows",
     fn(){
-        assertEquals(osWin, true);
+        assertEquals(osWindows, true);
+        assertEquals(osMac, false);
+        assertEquals(osLinux, false);
     }
 });
 
 Deno.test({
-    ignore: Deno.build.os === "windows",
-    name: "Platform: Unix",
+    ignore: Deno.build.os !== "darwin",
+    name: "OS: Mac",
     fn(){
-        assertEquals(osWin, false);
+        assertEquals(osWindows, false);
+        assertEquals(osMac, true);
+        assertEquals(osLinux, false);
+    }
+});
+
+Deno.test({
+    ignore: Deno.build.os !== "linux",
+    name: "OS: Linux",
+    fn(){
+        assertEquals(osWindows, false);
+        assertEquals(osMac, false);
+        assertEquals(osLinux, true);
     }
 });
\ No newline at end of file
diff --git a/test/deno/path.test.ts b/test/deno/path.test.ts
index e8399ee..12c6892 100644
--- a/test/deno/path.test.ts
+++ b/test/deno/path.test.ts
@@ -1,5 +1,5 @@
 import {assertEquals, dirname, fromFileUrl} from "../../deps.test.ts";
-import {slashU, slashW, tmpPath, dataPath, configPath, homePath, mainPath} from "../../src/deno/path.ts";
+import {pathSepL, pathSepW, pathTmp, pathVar, pathConfig, pathHome, pathMain} from "../../src/deno/path.ts";
 
 const {HOME, USERPROFILE} = Deno.env.toObject();
 const ep = `${fromFileUrl(dirname(Deno.mainModule))}/`;
@@ -10,8 +10,8 @@ Deno.test({
         const sampleUnix = "C:/Windows/System32/cmd.exe";
         const sampleWindows = "C:\\Windows\\System32\\cmd.exe";
 
-        assertEquals(slashU(sampleWindows), sampleUnix);
-        assertEquals(slashW(sampleUnix), sampleWindows);
+        assertEquals(pathSepL(sampleWindows), sampleUnix);
+        assertEquals(pathSepW(sampleUnix), sampleWindows);
     }
 });
 
@@ -19,11 +19,11 @@ Deno.test({
     ignore: Deno.build.os !== "windows",
     name: "Path: Windows",
     fn(){
-        assertEquals(tmpPath(), "C:/Windows/Temp");
-        assertEquals(dataPath(), "C:/ProgramData");
-        assertEquals(configPath(), `${slashU(USERPROFILE)}/AppData/Roaming`);
-        assertEquals(homePath(), slashU(USERPROFILE));
-        assertEquals(mainPath(), slashU(ep));
+        assertEquals(pathTmp(), "C:/Windows/Temp");
+        assertEquals(pathVar(), "C:/ProgramData");
+        assertEquals(pathConfig(), `${pathSepL(USERPROFILE)}/AppData/Roaming`);
+        assertEquals(pathHome(), pathSepL(USERPROFILE));
+        assertEquals(pathMain(), pathSepL(ep));
     }
 });
 
@@ -31,10 +31,10 @@ Deno.test({
     ignore: Deno.build.os === "windows",
     name: "Path: Unix",
     fn(){
-        assertEquals(tmpPath(), "/tmp");
-        assertEquals(dataPath(), "/var");
-        assertEquals(configPath(), `${HOME}/.config`);
-        assertEquals(homePath(), HOME);
-        assertEquals(mainPath(), ep);
+        assertEquals(pathTmp(), "/tmp");
+        assertEquals(pathVar(), "/var");
+        assertEquals(pathConfig(), `${HOME}/.config`);
+        assertEquals(pathHome(), HOME);
+        assertEquals(pathMain(), ep);
     }
 });
\ No newline at end of file
diff --git a/test/deno/process.test.ts b/test/deno/process.test.ts
index 98dabe0..c6c3327 100644
--- a/test/deno/process.test.ts
+++ b/test/deno/process.test.ts
@@ -1,10 +1,10 @@
 import {assertEquals} from "../../deps.test.ts";
-import {runCommand} from "../../src/deno/process.ts";
+import {processRun} from "../../src/deno/process.ts";
 
 Deno.test({
     name: "Process: Run (no args)",
     async fn(){
-        const result = await runCommand("echo", "abcdefg");
+        const result = await processRun("echo", "abcdefg");
 
         assertEquals(result, true);
     }
diff --git a/test/deno_ext/dom.test.ts b/test/deno_ext/dom.test.ts
index 431b424..ea30b1b 100644
--- a/test/deno_ext/dom.test.ts
+++ b/test/deno_ext/dom.test.ts
@@ -1,5 +1,5 @@
 import {assertEquals, DOMParser} from "../../deps.test.ts";
-import {parseDOM, collectInputById, getElementsByName, getValueById, getValuesByName, getValueByRadioActive} from "../../src/deno_ext/dom.ts";
+import {domDecode, domValuesPerId, domValueById, domElementsByName, domValuesByName, domValueByRadioActive} from "../../src/deno_ext/dom.ts";
 
 const sample1 = "<input type='radio' id='aaa' name='aaa' value='123' checked><input type='radio' name='aaa' value='456'>";
 const sample2 = new DOMParser().parseFromString(sample1, "text/html")?.documentElement;
@@ -11,7 +11,7 @@ if(!sample2){
 Deno.test({
     name: "DOM: Parse HTML",
     fn(){
-        const result = parseDOM(sample1);
+        const result = domDecode(sample1);
 
         assertEquals(result.innerHTML, sample2.innerHTML);
     }
@@ -20,7 +20,7 @@ Deno.test({
 Deno.test({
     name: "DOM: Collect input/textarea by ID",
     fn(){
-        const result = collectInputById(sample2);
+        const result = domValuesPerId(sample2);
 
         assertEquals(result.aaa, "123");
     }
@@ -29,7 +29,7 @@ Deno.test({
 Deno.test({
     name: "DOM: Get value by ID",
     fn(){
-        const result = getValueById(sample2, "aaa");
+        const result = domValueById(sample2, "aaa");
 
         assertEquals(result, "123");
     }
@@ -38,7 +38,7 @@ Deno.test({
 Deno.test({
     name: "DOM: Get element by Name",
     fn(){
-        const result = getElementsByName(sample2, "aaa");
+        const result = domElementsByName(sample2, "aaa");
 
         assertEquals(result.length, 2);
     }
@@ -47,7 +47,7 @@ Deno.test({
 Deno.test({
     name: "DOM: Get values by Name",
     fn(){
-        const result = getValuesByName(sample2, "aaa");
+        const result = domValuesByName(sample2, "aaa");
 
         assertEquals(result, ["123", "456"]);
     }
@@ -56,7 +56,7 @@ Deno.test({
 Deno.test({
     name: "DOM: Get value by RadioActive",
     fn(){
-        const result = getValueByRadioActive(sample2, "aaa");
+        const result = domValueByRadioActive(sample2, "aaa");
 
         assertEquals(result, "123");
     }
diff --git a/test/pure/base64.test.ts b/test/pure/base64.test.ts
index 41273d7..0ccbce3 100644
--- a/test/pure/base64.test.ts
+++ b/test/pure/base64.test.ts
@@ -1,5 +1,5 @@
 import {assertEquals} from "../../deps.test.ts";
-import {b64Encode, b64Decode, b64DataURL} from "../../src/pure/base64.ts";
+import {base64Encode, base64EncodeDataURL, base64Decode} from "../../src/pure/base64.ts";
 
 const sample1 = new Uint8Array([
     0x58, 0x0D, 0xC7, 0x64, 0x21, 0x42, 0x27, 0x76,
@@ -13,26 +13,26 @@ const sample2 = "WA3HZCFCJ3Yupv6eWKOTmpoHV65OWy/Heu/Xr/UfKjo=";
 Deno.test({
     name: "Base64: Encode",
     fn(){
-        const encode = b64Encode(sample1);
+        const encode = base64Encode(sample1);
 
         assertEquals(encode, sample2);
     }
 });
 
 Deno.test({
-    name: "Base64: Decode",
+    name: "Base64: DataURL",
     fn(){
-        const decode = b64Decode(sample2);
+        const encode = base64EncodeDataURL(sample1);
 
-        assertEquals(decode, sample1);
+        assertEquals(encode, `data:application/octet-stream;base64,${sample2}`);
     }
 });
 
 Deno.test({
-    name: "Base64: DataURL",
+    name: "Base64: Decode",
     fn(){
-        const encode = b64DataURL(sample1);
+        const decode = base64Decode(sample2);
 
-        assertEquals(encode, `data:application/octet-stream;base64,${sample2}`);
+        assertEquals(decode, sample1);
     }
 });
\ No newline at end of file
diff --git a/test/pure/crypto.test.ts b/test/pure/crypto.test.ts
index ffa2499..b66db05 100644
--- a/test/pure/crypto.test.ts
+++ b/test/pure/crypto.test.ts
@@ -1,5 +1,5 @@
 import {assertEquals} from "../../deps.test.ts";
-import {generateRandom, deriveHash, pkGenerateECDH, pkGenerateECDSA, pkEncrypt, pkDecrypt, pkSign, pkVerify} from "../../src/pure/crypto.ts";
+import {cryptoRandom, cryptoHash, cryptoGenerateEncryptKey, cryptoGenerateSignKey, cryptoEncrypt, cryptoDecrypt, cryptoSign, cryptoVerify} from "../../src/pure/crypto.ts";
 
 const sample = new Uint8Array([0x02, 0xF2, 0x5D, 0x1F, 0x1C, 0x34, 0xB9, 0x2F]);
 
@@ -17,7 +17,7 @@ const hashResult = new Uint8Array([
 Deno.test({
     name: "Crypto: Random",
     fn(){
-        const {byteLength} = generateRandom(16);
+        const {byteLength} = cryptoRandom(16);
 
         assertEquals(byteLength, 16);
     }
@@ -26,7 +26,7 @@ Deno.test({
 Deno.test({
     name: "Crypto: Hash",
     async fn(){
-        const hash = await deriveHash(sample, "SHA-512");
+        const hash = await cryptoHash(sample, "SHA-512");
 
         assertEquals(hash, hashResult);
     }
@@ -35,15 +35,15 @@ Deno.test({
 Deno.test({
     name: "Crypto: Encrypt and Decrypt",
     async fn(){
-        const key1 = await pkGenerateECDH();
-        const key2 = await pkGenerateECDH();
+        const key1 = await cryptoGenerateEncryptKey();
+        const key2 = await cryptoGenerateEncryptKey();
 
-        const encrypt = await pkEncrypt(sample, {
+        const encrypt = await cryptoEncrypt(sample, {
             publicKey: key1.publicKey,
             privateKey: key2.privateKey
         });
 
-        const decrypt = await pkDecrypt(encrypt, {
+        const decrypt = await cryptoDecrypt(encrypt, {
             publicKey: key2.publicKey,
             privateKey: key1.privateKey
         });
@@ -55,9 +55,9 @@ Deno.test({
 Deno.test({
     name: "Crypto: Sign and Verify",
     async fn(){
-        const key = await pkGenerateECDSA();
-        const signature = await pkSign(sample, key.privateKey);
-        const verify = await pkVerify(sample, key.publicKey, signature);
+        const key = await cryptoGenerateSignKey();
+        const signature = await cryptoSign(sample, key.privateKey);
+        const verify = await cryptoVerify(sample, key.publicKey, signature);
 
         assertEquals(verify, true);
     }
diff --git a/test/pure/text.test.ts b/test/pure/text.test.ts
index 8ea62c8..5477c7d 100644
--- a/test/pure/text.test.ts
+++ b/test/pure/text.test.ts
@@ -1,5 +1,5 @@
 import {assertEquals} from "../../deps.test.ts";
-import {u8Encode, u8Decode, textDecode, hexEncode, hexDecode, trimExtend, fixWidth, cleanText, accurateSegment, pad0} from "../../src/pure/text.ts";
+import {textEncode, textDecode, textDecodeAny, textHexEncode, textHexDecode, textPurgeSuperfluous, textFixWidth, textGetReady, textSplitBySegment, textPadZero} from "../../src/pure/text.ts";
 
 const sampleText = "  Lorem ipsum\r dolor   sit  \r\r amet. ";
 const sampleBin = new Uint8Array([
@@ -15,8 +15,8 @@ const sjisBin = new Uint8Array([0x82, 0xB1, 0x82, 0xF1, 0x82, 0xC9, 0x82, 0xBF,
 Deno.test({
     name: "Text: UTF-8 Encode and Decode",
     fn(){
-        const encode = u8Encode(sampleText);
-        const decode = u8Decode(encode);
+        const encode = textEncode(sampleText);
+        const decode = textDecode(encode);
 
         assertEquals(decode, sampleText);
     }
@@ -25,7 +25,7 @@ Deno.test({
 Deno.test({
     name: "Text: Any Text Decode",
     fn(){
-        const decode = textDecode(sjisBin);
+        const decode = textDecodeAny(sjisBin);
 
         assertEquals(decode, "こんにちは");
     }
@@ -34,8 +34,8 @@ Deno.test({
 Deno.test({
     name: "Text: HEX Encode and Decode",
     fn(){
-        const encode = hexEncode(sampleBin);
-        const decode = hexDecode(encode);
+        const encode = textHexEncode(sampleBin);
+        const decode = textHexDecode(encode);
 
         assertEquals(decode, sampleBin);
     }
@@ -44,7 +44,7 @@ Deno.test({
 Deno.test({
     name: "Text: Trim",
     fn(){
-        const result = trimExtend(sampleText);
+        const result = textPurgeSuperfluous(sampleText);
 
         assertEquals(result, "Lorem ipsum dolor sit amet.");
     }
@@ -53,7 +53,7 @@ Deno.test({
 Deno.test({
     name: "Text: Fix Width",
     fn(){
-        const result = fixWidth("１＋１＝２");
+        const result = textFixWidth("１＋１＝２");
 
         assertEquals(result, "1+1=2");
     }
@@ -62,7 +62,7 @@ Deno.test({
 Deno.test({
     name: "Text: Clean Up",
     fn(){
-        const result = cleanText("１  ＋  １  ＝  ２  ");
+        const result = textGetReady("１  ＋  １  ＝  ２  ");
 
         assertEquals(result, "1 + 1 = 2");
     }
@@ -71,7 +71,7 @@ Deno.test({
 Deno.test({
     name: "Text: Segment",
     fn(){
-        const {length} = accurateSegment("😄😁😆😅😂");
+        const {length} = textSplitBySegment("😄😁😆😅😂");
 
         assertEquals(length, 5);
     }
@@ -80,7 +80,7 @@ Deno.test({
 Deno.test({
     name: "Text: Pad 0",
     fn(){
-        const pad = pad0(8);
+        const pad = textPadZero(8);
 
         assertEquals(pad, "08");
     }
diff --git a/test/pure/time.test.ts b/test/pure/time.test.ts
index 8b3b5b1..b46a802 100644
--- a/test/pure/time.test.ts
+++ b/test/pure/time.test.ts
@@ -1,27 +1,18 @@
 import {assertEquals} from "../../deps.test.ts";
-import {utEncode, utDecode, utParse, delay, dtSerial} from "../../src/pure/time.ts";
+import {delay, timeEncode, timeDecode, timeFormatSerialize} from "../../src/pure/time.ts";
 
 const sample = new Date(2000, 0, 1, 0, 0, 0, 0);
 
 Deno.test({
     name: "Time: Encode and Decode",
     fn(){
-        const encode = utEncode(sample);
-        const decode = utDecode(encode);
+        const encode = timeEncode(sample);
+        const decode = timeDecode(encode);
 
         assertEquals(decode, sample);
     }
 });
 
-Deno.test({
-    name: "Time: Parse",
-    fn(){
-        const result = utParse(sample.toISOString());
-
-        assertEquals(result, 946684800);
-    }
-});
-
 Deno.test({
     name: "Time: Delay",
     async fn(){
@@ -34,7 +25,7 @@ Deno.test({
 Deno.test({
     name: "Time: Serial",
     fn(){
-        const result = dtSerial(sample);
+        const result = timeFormatSerialize(sample);
 
         assertEquals(result, "20000101000000");
     }
diff --git a/test/pure/worker.test.ts b/test/pure/worker.test.ts
index 3720e42..a368912 100644
--- a/test/pure/worker.test.ts
+++ b/test/pure/worker.test.ts
@@ -1,5 +1,5 @@
 import {assertEquals} from "../../deps.test.ts";
-import {createTask} from "../../src/pure/worker.ts";
+import {workerTask} from "../../src/pure/worker.ts";
 
 const sample1 = new Uint8Array([1, 2, 3, 4]);
 const sample2 = new Uint8Array([2, 4, 6, 8]);
@@ -7,7 +7,7 @@ const sample2 = new Uint8Array([2, 4, 6, 8]);
 Deno.test({
     name: "Worker: Create Task.",
     async fn(){
-        const task = createTask<Uint8Array, Uint8Array>((v)=>{
+        const task = workerTask<Uint8Array, Uint8Array>((v)=>{
             const result = v.map(n => n * 2);
 
             return {