From 702b8d00b18c3d47af068efc3b2507a770d14419 Mon Sep 17 00:00:00 2001
From: dojyorin <ota_droid@live.jp>
Date: Sun, 28 Jan 2024 21:48:42 +0900
Subject: [PATCH] update.

---
 deps.pure_ext.ts           |  2 +-
 src/deno/json.ts           |  8 ++---
 src/deno/path.ts           |  2 +-
 src/deno_ext/dom.ts        | 67 ++++++++++++++++----------------------
 src/deno_ext/log.ts        |  5 ++-
 src/deno_ext/smtp.ts       | 12 +++----
 src/pure/byte.ts           |  8 ++---
 src/pure/crypto.ts         | 32 +++++++++---------
 src/pure/deep.ts           |  2 +-
 src/pure/deflate.ts        | 20 +++++++-----
 src/pure/fetch.ts          |  2 +-
 src/pure/minipack.ts       | 18 +++++-----
 src/pure/primitive.ts      | 12 +++----
 src/pure/stream.ts         | 11 ++++---
 src/pure/text.ts           | 26 +++++++--------
 src/pure/time.ts           | 16 ++++++---
 src/pure/worker.ts         | 19 +++++------
 src/pure_ext/csv.ts        |  2 +-
 src/pure_ext/excel.ts      | 14 ++++----
 test/deno/path.test.ts     |  4 ++-
 test/deno_ext/smtp.test.ts |  2 +-
 test/pure/crypto.test.ts   | 12 +++----
 test/pure/text.test.ts     |  6 ++--
 test/pure/time.test.ts     |  2 ++
 24 files changed, 149 insertions(+), 155 deletions(-)

diff --git a/deps.pure_ext.ts b/deps.pure_ext.ts
index f335867..9144e9d 100644
--- a/deps.pure_ext.ts
+++ b/deps.pure_ext.ts
@@ -3,5 +3,5 @@ export {parse, stringify} from "https://deno.land/std@0.213.0/csv/mod.ts";
 export {ZipReader, ZipWriter, Uint8ArrayReader, Uint8ArrayWriter} from "https://deno.land/x/zipjs@v2.7.32/index.js";
 
 // @deno-types="https://cdn.sheetjs.com/xlsx-0.20.1/package/types/index.d.ts"
-export {type WorkBook, type WorkSheet, type CellObject, set_cptable, read as xlsxRead, write as xlsxWrite, utils as xlsxUtil} from "https://cdn.sheetjs.com/xlsx-0.20.1/package/xlsx.mjs";
+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.1/package/xlsx.mjs";
 export * as xlsxcp from "https://cdn.sheetjs.com/xlsx-0.20.1/package/dist/cpexcel.full.mjs";
\ No newline at end of file
diff --git a/src/deno/json.ts b/src/deno/json.ts
index 232f475..615a64c 100644
--- a/src/deno/json.ts
+++ b/src/deno/json.ts
@@ -4,7 +4,7 @@ import {type Opt} from "../pure/deep.ts";
 * Read JSON file and convert to object.
 * @example
 * ```ts
-* const json = await jsonRead("./resource.json");
+* const json = await jsonRead("./data.json");
 * ```
 */
 export async function jsonRead<T extends Opt<T>>(path:string):Promise<T>{
@@ -15,7 +15,7 @@ export async function jsonRead<T extends Opt<T>>(path:string):Promise<T>{
 * Convert from object to JSON and write to file.
 * @example
 * ```ts
-* await jsonWrite("./resource.json", {
+* await jsonWrite("./data.json", {
 *     foo: "bar"
 * });
 * ```
@@ -30,8 +30,8 @@ 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 dresource from "./resource.json" assert {type: "json"};
-* const resource = await jsonLoad("./resource.json", dresource);
+* import data from "./data.json" assert {type: "json"};
+* const json = await jsonLoad("./data.json", data);
 * ```
 */
 export async function jsonLoad<T extends Opt<T>>(path:string, def:T):Promise<T>{
diff --git a/src/deno/path.ts b/src/deno/path.ts
index 85fc72e..696b86a 100644
--- a/src/deno/path.ts
+++ b/src/deno/path.ts
@@ -61,7 +61,7 @@ export function configPath():string{
 }
 
 /**
-* System-wide home path for each OS.
+* System-wide home directory path for each OS.
 * `${HOME}` for UNIX and `%USERPROFILE%` for Windows.
 * @example
 * ```ts
diff --git a/src/deno_ext/dom.ts b/src/deno_ext/dom.ts
index d13dcb0..2a68e3a 100644
--- a/src/deno_ext/dom.ts
+++ b/src/deno_ext/dom.ts
@@ -1,26 +1,21 @@
 import {type Element, DOMParser} from "../../deps.deno_ext.ts";
 import {type FetchInit, fetchExtend} from "../pure/fetch.ts";
 import {deepClone} from "../pure/deep.ts";
-import {cleanText} from "../pure/text.ts";
 
 function selectedElement(elements:Element[], attribute:"checked" | "selected"){
-    return elements.find(e => typeof e.getAttribute(attribute) === "string");
+    return elements.find(v => typeof v.getAttribute(attribute) === "string");
 }
 
-function getContent({textContent}:Element){
-    return cleanText(textContent);
+function getValue(element?:Element){
+    return element?.getAttribute("value") ?? "";
 }
 
-function getValue(element?:Element){
-    return cleanText(element?.getAttribute("value") ?? "");
+function getContent({textContent}:Element){
+    return textContent;
 }
 
 function extractValue(element?:Element){
-    if(!element){
-        return "";
-    }
-
-    switch(element.tagName){
+    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);
@@ -35,7 +30,7 @@ function extractValue(element?:Element){
 * @see https://deno.land/x/deno_dom
 * @example
 * ```ts
-* const element = await fetchDOM("https://www.google.com");
+* const dom = await fetchDOM("https://www.google.com");
 * ```
 */
 export async function fetchDOM(path:string, option?:FetchInit):Promise<Element>{
@@ -47,8 +42,7 @@ export async function fetchDOM(path:string, option?:FetchInit):Promise<Element>{
 * @see https://deno.land/x/deno_dom
 * @example
 * ```ts
-* const html = "<div>foo</div>";
-* const element = parseDOM(html);
+* const dom = parseDOM("<div>foo</div>");
 * ```
 */
 export function parseDOM(html:string):Element{
@@ -65,28 +59,27 @@ export function parseDOM(html:string):Element{
 * Find all `input` `textarea` elements with `id` attribute and convert them to key-value record.
 * @example
 * ```ts
-* const html = "<input id='foo'><textarea id='bar'></textarea>";
-* const element = parseHtml(html);
-* const result = collectInputById(element);
+* const dom = parseDOM("<input id='foo'><textarea id='bar'></textarea>");
+* const result = collectInputById(dom);
 * ```
 */
 export function collectInputById(element:Element):Record<string, string>{
     const records:Record<string, string> = {};
 
-    for(const e of element.getElementsByTagName("INPUT")){
-        if(!e.id){
+    for(const input of element.getElementsByTagName("INPUT")){
+        if(!input.id){
             continue;
         }
 
-        records[e.id] = getValue(e);
+        records[input.id] = getValue(input);
     }
 
-    for(const e of element.getElementsByTagName("TEXTAREA")){
-        if(!e.id){
+    for(const textarea of element.getElementsByTagName("TEXTAREA")){
+        if(!textarea.id){
             continue;
         }
 
-        records[e.id] = getContent(e);
+        records[textarea.id] = getContent(textarea);
     }
 
     return deepClone(records);
@@ -96,23 +89,21 @@ export function collectInputById(element:Element):Record<string, string>{
 * Find all elements with `name` attribute.
 * @example
 * ```ts
-* const html = "<input name='foo'>";
-* const element = parseHtml(html);
-* const result = getElementsByName(element, "foo");
+* const dom = parseDOM("<input name='foo'>");
+* const result = getElementsByName(dom, "foo");
 * ```
 */
 export function getElementsByName(element:Element, name:string):Element[]{
-    return element.getElementsByTagName("*").filter(e => e.getAttribute("name") === name);
+    return element.getElementsByTagName("*").filter(v => v.getAttribute("name") === name);
 }
 
 /**
 * Get value by `id` search.
 * `.value` for `<input>`, `.textContent` for `<textarea>` and `.value` of `.selected` for `<select>` `<dataset>`.
 * @example
-* ```ts
-* const html = "<input id='foo'>";
-* const element = parseHtml(html);
-* const result = getValueById(element, "foo");
+* ```ts\
+* const dom = parseDOM("<input id='foo'>");
+* const result = getValueById(dom, "foo");
 * ```
 */
 export function getValueById(element:Element, id:string):string{
@@ -124,28 +115,26 @@ export function getValueById(element:Element, id:string):string{
 * `.value` for `<input>`, `.textContent` for `<textarea>` and `.value` of `.selected` for `<select>` `<dataset>`.
 * @example
 * ```ts
-* const html = "<input name='foo'>";
-* const element = parseHtml(html);
-* const result = getValuesByName(element, "foo");
+* const dom = parseDOM("<input name='foo'>");
+* const result = getValuesByName(dom, "foo");
 * ```
 */
 export function getValuesByName(element:Element, name:string):string[]{
-    return getElementsByName(element, name).map(e => extractValue(e));
+    return getElementsByName(element, name).map(v => extractValue(v));
 }
 
 /**
 * Gets value of `.checked` in group of radio buttons.
 * @example
 * ```ts
-* const html = "<input type='radio' name='foo' value='1' checked><input type='radio' name='foo' value='2'>";
-* const element = parseHtml(html);
-* const result = getValueByRadioActive(element, "foo");
+* const dom = parseDOM("<input type='radio' name='foo' value='1' checked><input type='radio' name='foo' value='2'>");
+* const result = getValueByRadioActive(dom, "foo");
 * ```
 */
 export function getValueByRadioActive(element:Element, name:string):string{
     const elements = getElementsByName(element, name);
 
-    if(elements.some(e => e.tagName !== "INPUT" || e.getAttribute("type") !== "radio")){
+    if(elements.some(v => v.tagName !== "INPUT" || v.getAttribute("type") !== "radio")){
         return "";
     }
 
diff --git a/src/deno_ext/log.ts b/src/deno_ext/log.ts
index ccb6fe7..2445fe2 100644
--- a/src/deno_ext/log.ts
+++ b/src/deno_ext/log.ts
@@ -5,9 +5,8 @@ function logRecord(date:Date, level:string, message:string){
 }
 
 /**
-* Instantiate logger with general configuration.
-* Output to console and also to file if `name` is defined.
-* Log file default save path is `${Deno.mainModule}/${name}.log`.
+* Start logging.
+* Output to console for general and also write to file if `path` is defined.
 * @see https://deno.land/std/log
 * @example
 * ```ts
diff --git a/src/deno_ext/smtp.ts b/src/deno_ext/smtp.ts
index 7d94a18..197b8b2 100644
--- a/src/deno_ext/smtp.ts
+++ b/src/deno_ext/smtp.ts
@@ -6,11 +6,11 @@ import {type DataMap} from "../pure/minipack.ts";
 */
 export interface MailMessage{
     from: string;
-    to: string | string[];
-    cc?: string | string[];
-    bcc?: string | string[];
+    to: string[];
     title: string;
     body: string;
+    cc?: string[];
+    bcc?: string[];
     files?: DataMap[];
 }
 
@@ -19,9 +19,9 @@ export interface MailMessage{
 * @see https://www.npmjs.com/package/nodemailer
 * @example
 * ```ts
-* const ok = await smtpSend("smtp://smtp.example.com:25", {
-*     from: "mike@xxx.com",
-*     to: "john@xxx.com",
+* await smtpSend("smtp://smtp.example.com:25", {
+*     from: "mike@example.com",
+*     to: ["john@example.com"],
 *     title: "test",
 *     body: "test mail."
 * });
diff --git a/src/pure/byte.ts b/src/pure/byte.ts
index 4819651..f509658 100644
--- a/src/pure/byte.ts
+++ b/src/pure/byte.ts
@@ -12,8 +12,8 @@ interface BlobType{
 * Convert from blob to specified data type.
 * @example
 * ```ts
-* const file = new File(["my-text"], "example.txt");
-* const data = await blobConvert(file, "text");
+* const blob = new Blob(["my-text"]);
+* const data = await blobConvert(blob, "text");
 * ```
 */
 export async function blobConvert<T extends keyof BlobType>(blob:Blob, type:T):Promise<BlobType[T]>{
@@ -28,14 +28,14 @@ export async function blobConvert<T extends keyof BlobType>(blob:Blob, type:T):P
 }
 
 /**
-* Concat multiple buffer sources into single Uint8Array.
+* Concat multiple buffer sources into single binary.
 * @example
 * ```ts
 * const byte = byteConcat(new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6]));
 * ```
 */
 export function byteConcat(...sources:BufferSource[]):Uint8Array{
-    const output = new Uint8Array(sources.reduce((n, {byteLength}) => n + byteLength , 0));
+    const output = new Uint8Array(sources.reduce((v, {byteLength}) => v + byteLength , 0));
 
     let i = 0;
     for(const source of sources){
diff --git a/src/pure/crypto.ts b/src/pure/crypto.ts
index 6068d12..431bf99 100644
--- a/src/pure/crypto.ts
+++ b/src/pure/crypto.ts
@@ -100,17 +100,17 @@ export async function pkGenerateECDSA():Promise<PortableCryptoKeyPair>{
 * const bin = await Deno.readFile("./file");
 * const k1 = await pkGenerateECDH();
 * const k2 = await pkGenerateECDH();
-* const cipher = await pkEncrypt({
+* const cipher = await pkEncrypt(bin, {
 *     publicKey: k1.publicKey,
 *     privateKey: k2.privateKey
-* }, bin);
-* const decrypt = await pkDecrypt({
+* });
+* const decrypt = await pkDecrypt(cipher, {
 *     publicKey: k2.publicKey,
 *     privateKey: k1.privateKey
-* }, cipher);
+* });
 * ```
 */
-export async function pkEncrypt({publicKey, privateKey}:PortableCryptoKeyPair, data:Uint8Array):Promise<Uint8Array>{
+export async function pkEncrypt(data:Uint8Array, {publicKey, privateKey}:PortableCryptoKeyPair):Promise<Uint8Array>{
     const aes = {
         name: AES_MODE,
         iv: generateRandom(12)
@@ -132,17 +132,17 @@ export async function pkEncrypt({publicKey, privateKey}:PortableCryptoKeyPair, d
 * const bin = await Deno.readFile("./file");
 * const k1 = await pkGenerateECDH();
 * const k2 = await pkGenerateECDH();
-* const cipher = await pkEncrypt({
+* const cipher = await pkEncrypt(bin, {
 *     publicKey: k1.publicKey,
 *     privateKey: k2.privateKey
-* }, bin);
-* const decrypt = await pkDecrypt({
+* });
+* const decrypt = await pkDecrypt(cipher, {
 *     publicKey: k2.publicKey,
 *     privateKey: k1.privateKey
-* }, cipher);
+* });
 * ```
 */
-export async function pkDecrypt({publicKey, privateKey}:PortableCryptoKeyPair, data:Uint8Array):Promise<Uint8Array>{
+export async function pkDecrypt(data:Uint8Array, {publicKey, privateKey}:PortableCryptoKeyPair):Promise<Uint8Array>{
     const aes = {
         name: AES_MODE,
         iv: data.subarray(0, 12)
@@ -157,11 +157,11 @@ export async function pkDecrypt({publicKey, privateKey}:PortableCryptoKeyPair, d
 * ```ts
 * const bin = await Deno.readFile("./file");
 * const {publicKey, privateKey} = await pkGenerateECDSA();
-* const sign = await pkSign(privateKey, bin);
-* const verify = await pkVerify(publicKey, sign, bin);
+* const sign = await pkSign(bin, privateKey);
+* const verify = await pkVerify(bin, publicKey, sign);
 * ```
 */
-export async function pkSign(key:Uint8Array, data:Uint8Array):Promise<Uint8Array>{
+export async function pkSign(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));
 }
 
@@ -171,10 +171,10 @@ export async function pkSign(key:Uint8Array, data:Uint8Array):Promise<Uint8Array
 * ```ts
 * const bin = await Deno.readFile("./file");
 * const {publicKey, privateKey} = await pkGenerateECDSA();
-* const sign = await pkSign(privateKey, bin);
-* const verify = await pkVerify(publicKey, sign, bin);
+* const sign = await pkSign(bin, privateKey);
+* const verify = await pkVerify(bin, publicKey, sign);
 * ```
 */
-export async function pkVerify(key:Uint8Array, sign:Uint8Array, data:Uint8Array):Promise<boolean>{
+export async function pkVerify(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 2060ad2..35e5abd 100644
--- a/src/pure/deep.ts
+++ b/src/pure/deep.ts
@@ -8,7 +8,7 @@ function hasObject(data:Record<string | number | symbol, unknown>, key:string){
 }
 
 /**
-* `structuredClone()` with argument type added to return value.
+* `structuredClone()` with argument type added.
 * @example
 * ```ts
 * const clone = deepClone({
diff --git a/src/pure/deflate.ts b/src/pure/deflate.ts
index fd00cec..ac0a376 100644
--- a/src/pure/deflate.ts
+++ b/src/pure/deflate.ts
@@ -1,10 +1,12 @@
 import {streamEncode, streamDecode} from "./stream.ts";
 
-const DEFLATE_CODEC = "deflate-raw";
+type CompressCodec = "gzip" | "deflate" | "deflate-raw";
+
+const COMPRESS_CODEC = "deflate-raw";
 
 /**
-* Compress binary with "deflate" format.
-* Does not contain header such as "gzip" (RFC1952) or "zlib" (RFC1950).
+* Compress binary with DEFLATE format.
+* Default codec is DEFLATE with no header (RFC-1951) and name in WebAPI specification is `"deflate-raw"`.
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
@@ -12,13 +14,13 @@ const DEFLATE_CODEC = "deflate-raw";
 * const decode = await deflateDecode(encode);
 * ```
 */
-export async function deflateEncode(data:Uint8Array, codec?:string):Promise<Uint8Array>{
-    return await streamDecode(streamEncode(data).pipeThrough(new CompressionStream(codec ?? DEFLATE_CODEC)));
+export async function deflateEncode(data:Uint8Array, codec?:CompressCodec):Promise<Uint8Array>{
+    return await streamDecode(streamEncode(data).pipeThrough(new CompressionStream(codec ?? COMPRESS_CODEC)));
 }
 
 /**
-* Decompress "deflate" format binary.
-* Cannot decompress such as "gzip" (RFC1952) or "zlib" (RFC1950) that contain header.
+* Decompress DEFLATE format binary.
+* Default codec is DEFLATE with no header (RFC-1951) and name in WebAPI specification is `"deflate-raw"`.
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
@@ -26,6 +28,6 @@ export async function deflateEncode(data:Uint8Array, codec?:string):Promise<Uint
 * const decode = await deflateDecode(encode);
 * ```
 */
-export async function deflateDecode(data:Uint8Array, codec?:string):Promise<Uint8Array>{
-    return await streamDecode(streamEncode(data).pipeThrough(new DecompressionStream(codec ?? DEFLATE_CODEC)));
+export async function deflateDecode(data:Uint8Array, codec?:CompressCodec):Promise<Uint8Array>{
+    return await streamDecode(streamEncode(data).pipeThrough(new DecompressionStream(codec ?? COMPRESS_CODEC)));
 }
\ No newline at end of file
diff --git a/src/pure/fetch.ts b/src/pure/fetch.ts
index d73236f..f115b2a 100644
--- a/src/pure/fetch.ts
+++ b/src/pure/fetch.ts
@@ -15,7 +15,7 @@ interface ResponseType{
 }
 
 /**
-* `RequestInit` with added `query` property that can specify query string.
+* Added `query` which allows you to specify query string and `secret` which allows you to specify secret value to `RequestInit`.
 */
 export interface FetchInit extends Omit<RequestInit, "integrity" | "window">{
     signal?: AbortSignal;
diff --git a/src/pure/minipack.ts b/src/pure/minipack.ts
index 689bf8c..634bf1f 100644
--- a/src/pure/minipack.ts
+++ b/src/pure/minipack.ts
@@ -16,10 +16,10 @@ export interface DataMap{
 * @see https://deno.land/x/simple_utility#minipack
 * @example
 * ```ts
-* const files = [
-*     ["file1", await Deno.readFile("./file1")],
-*     ["file2", await Deno.readFile("./file2")]
-* ];
+* const files = [{
+*     name: "foo.txt",
+*     body: await Deno.readFile("./foo.txt")
+* }];
 * const encode = minipackEncode(files);
 * const decode = minipackDecode(encode);
 * ```
@@ -48,14 +48,14 @@ export function minipackEncode(files:DataMap[]):Uint8Array{
 }
 
 /**
-* Decode byte array in "minipack" format.
+* Decode binary of "minipack" format.
 * @see https://deno.land/x/simple_utility#minipack
 * @example
 * ```ts
-* const files = [
-*     ["file1", await Deno.readFile("./file1")],
-*     ["file2", await Deno.readFile("./file2")]
-* ];
+* const files = [{
+*     name: "foo.txt",
+*     body: await Deno.readFile("./foo.txt")
+* }];
 * const encode = minipackEncode(files);
 * const decode = minipackDecode(encode);
 * ```
diff --git a/src/pure/primitive.ts b/src/pure/primitive.ts
index 856c062..0ebf77a 100644
--- a/src/pure/primitive.ts
+++ b/src/pure/primitive.ts
@@ -8,7 +8,7 @@ interface PrimitiveMap{
     "boolean": boolean;
 }
 
-function undef(strict?:boolean){
+function strictUndef(strict?:boolean){
     if(strict){
         throw new Error();
     }
@@ -18,7 +18,7 @@ function undef(strict?:boolean){
 
 /**
 * Convert from dirty text to specified type.
-* Enabling `strict` flag will throw exception if parsing is not possible.
+* Enabling `strict` flag will throw exception if parsing failed.
 * @example
 * ```ts
 * const value = primitiveParse("123", "number", true);
@@ -30,7 +30,7 @@ export function primitiveParse<T extends keyof PrimitiveMap, U extends boolean>(
             const v = String(text);
 
             if(text === undefined || text === null){
-                return <TypeStrict<PrimitiveMap[T], U>>undef(strict);
+                return <TypeStrict<PrimitiveMap[T], U>>strictUndef(strict);
             }
 
             return <TypeStrict<PrimitiveMap[T], U>>v;
@@ -40,7 +40,7 @@ export function primitiveParse<T extends keyof PrimitiveMap, U extends boolean>(
             const v = Number(text);
 
             if(text === undefined || text === null || isNaN(v)){
-                return <TypeStrict<PrimitiveMap[T], U>>undef(strict);
+                return <TypeStrict<PrimitiveMap[T], U>>strictUndef(strict);
             }
 
             return <TypeStrict<PrimitiveMap[T], U>>v;
@@ -50,7 +50,7 @@ export function primitiveParse<T extends keyof PrimitiveMap, U extends boolean>(
             switch(text){
                 case "true": return <TypeStrict<PrimitiveMap[T], U>>true;
                 case "false": return <TypeStrict<PrimitiveMap[T], U>>false;
-                default: return <TypeStrict<PrimitiveMap[T], U>>undef(strict);
+                default: return <TypeStrict<PrimitiveMap[T], U>>strictUndef(strict);
             }
         }
 
@@ -60,7 +60,7 @@ export function primitiveParse<T extends keyof PrimitiveMap, U extends boolean>(
 
 /**
 * Convert from dirty text to specified type.
-* If cannot be parsed, use default (`def`) value.
+* If parsing failed use default (`def`) value.
 * Convert to same type as default value.
 * @example
 * ```ts
diff --git a/src/pure/stream.ts b/src/pure/stream.ts
index c0328a3..e26dcdd 100644
--- a/src/pure/stream.ts
+++ b/src/pure/stream.ts
@@ -2,7 +2,8 @@
 * Convert from binary to stream.
 * @example
 * ```ts
-* const rs = streamEncode(new Uint8Array([0x00, 0x01, 0x02]));
+* const stream = streamEncode(new Uint8Array([0x00, 0x01, 0x02]));
+* const data = await streamDecode(stream);
 * ```
 */
 export function streamEncode(data:Uint8Array):ReadableStream<Uint8Array>{
@@ -19,10 +20,10 @@ export function streamEncode(data:Uint8Array):ReadableStream<Uint8Array>{
 * Convert from stream to binary.
 * @example
 * ```ts
-* const rs = streamEncode(new Uint8Array([0x00, 0x01, 0x02]));
-* const data = await streamDecode(rs);
+* const stream = streamEncode(new Uint8Array([0x00, 0x01, 0x02]));
+* const data = await streamDecode(stream);
 * ```
 */
-export async function streamDecode(rs:ReadableStream<Uint8Array>):Promise<Uint8Array>{
-    return new Uint8Array(await new Response(rs).arrayBuffer());
+export async function streamDecode(stream:ReadableStream<Uint8Array>):Promise<Uint8Array>{
+    return new Uint8Array(await new Response(stream).arrayBuffer());
 }
\ No newline at end of file
diff --git a/src/pure/text.ts b/src/pure/text.ts
index abd97cb..f19ff20 100644
--- a/src/pure/text.ts
+++ b/src/pure/text.ts
@@ -25,15 +25,16 @@ export function u8Decode(data:Uint8Array):string{
 }
 
 /**
-* Convert from SHIFT-JIS binary to hex string.
+* Convert from any encoded binary to string.
+* Default codec is SHIFT-JIS.
 * @example
 * ```ts
 * const bin = await Deno.readFile("./file");
-* const decode = sjisDecode(bin);
+* const decode = textDecode(bin);
 * ```
 */
-export function sjisDecode(data:Uint8Array):string{
-    return new TextDecoder("shift-jis").decode(data);
+export function textDecode(data:Uint8Array, codec?:string):string{
+    return new TextDecoder(codec ?? "shift-jis").decode(data);
 }
 
 /**
@@ -66,8 +67,7 @@ export function hexDecode(data:string):Uint8Array{
 * Trim head and tail blank, remove CR and consecutive space (tab, LF) to single space (tab, LF).
 * @example
 * ```ts
-* const text = "  Lorem ipsum\r dolor   sit  \r\r amet. ";
-* const format = trimExtend(text);
+* const format = trimExtend("  Lorem ipsum\r dolor   sit  \r\r amet. ");
 * ```
 */
 export function trimExtend(data:string):string{
@@ -75,11 +75,10 @@ export function trimExtend(data:string):string{
 }
 
 /**
-* Convert half-width Japanese kana to full-width and full-width alphanumeric symbols to half-width.
+* Convert half-width string (ex: Japanese Kana) to full-width and full-width alphanumeric symbols to half-width.
 * @example
 * ```ts
-* const text = "１＋１＝２";
-* const format = fixWidth(text);
+* const format = fixWidth("１＋１＝２");
 * ```
 */
 export function fixWidth(data:string):string{
@@ -118,8 +117,7 @@ export function fixWidth(data:string):string{
 * Clean up text with `fixWidth()` and `trimExtend()`.
 * @example
 * ```ts
-* const text = "１  ＋  １  ＝  ２  ";
-* const format = cleanText(text);
+* const format = cleanText("１  ＋  １  ＝  ２  ");
 * ```
 */
 export function cleanText(data:string):string{
@@ -131,8 +129,7 @@ export function cleanText(data:string):string{
 * Useful for calculate number of characters with string contains emoji.
 * @example
 * ```ts
-* const text = "😀😃😄😁😆😅😂🤣";
-* const characters = accurateSegment(text);
+* const characters = accurateSegment("😀😃😄😁😆😅😂🤣");
 * ```
 */
 export function accurateSegment(data:string):string[]{
@@ -144,8 +141,7 @@ export function accurateSegment(data:string):string[]{
 * Output is 2 digits by default.
 * @example
 * ```ts
-* const num = 8;
-* const pad = pad0(num);
+* const pad = pad0(8);
 * ```
 */
 export function pad0(data:number, digit?:number, radix?:number):string{
diff --git a/src/pure/time.ts b/src/pure/time.ts
index 0678dbc..da43da1 100644
--- a/src/pure/time.ts
+++ b/src/pure/time.ts
@@ -1,8 +1,9 @@
 import {pad0} from "./text.ts";
 
 /**
-* Return UNIX time in seconds.
-* If no argument will be calculate at current time.
+* UNIX time in seconds.
+* If no args will be current time.
+* Note that in seconds not milliseconds.
 * @example
 * ```ts
 * const time = utEncode();
@@ -14,7 +15,7 @@ export function utEncode(date?:Date):number{
 }
 
 /**
-* Return `Date` from UNIX time.
+* `Date` from UNIX time.
 * Note that in seconds not milliseconds.
 * @example
 * ```ts
@@ -41,13 +42,18 @@ export function utParse(ds:string):number{
 
 /**
 * Wait for specified time.
+* Return actual elapsed wait time.
 * @example
 * ```ts
 * await delay(1000);
 * ```
 */
-export async function delay(ms:number):Promise<void>{
-    await new Promise<void>(done => setTimeout(done, ms));
+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);
 }
 
 /**
diff --git a/src/pure/worker.ts b/src/pure/worker.ts
index 12f130b..439e1d4 100644
--- a/src/pure/worker.ts
+++ b/src/pure/worker.ts
@@ -1,3 +1,8 @@
+interface TaskMessage<T extends unknown>{
+    message: T;
+    transfers?: (Transferable | ArrayBufferView)[];
+}
+
 /**
 * Content of processing run by worker thread.
 */
@@ -8,14 +13,6 @@ export type TaskAction<T extends unknown, K extends unknown> = (message:T) => Ta
 */
 export type TaskContext<T extends unknown, K extends unknown> = (message:T, transfers?:(Transferable | ArrayBufferView)[]) => Promise<K>;
 
-/**
-* Communication content between main thread and worker thread.
-*/
-export interface TaskMessage<T extends unknown>{
-    message: T;
-    transfers?: (Transferable | ArrayBufferView)[];
-}
-
 /**
 * Register `TaskAction` and return reusable task execution context.
 * `Worker` instance is created and destroyed each time they run `TaskContext`.
@@ -24,13 +21,13 @@ export interface TaskMessage<T extends unknown>{
 * ```ts
 * const task = createTask<number, number>(async(data)=>{
 *     const {delay} = await import("https://deno.land/std/async/mod.ts");
-*     await delay(1000);
+*     await delay(data);
 *     return {
 *         message: data * 2
 *     };
 * });
-* const result1 = await task(1);
-* const result2 = await task(2);
+* const result1 = await task(10);
+* const result2 = await task(20);
 * ```
 */
 export function createTask<T extends unknown, K extends unknown>(task:TaskAction<T, K>):TaskContext<T, K>{
diff --git a/src/pure_ext/csv.ts b/src/pure_ext/csv.ts
index 3d69ec3..bb84b97 100644
--- a/src/pure_ext/csv.ts
+++ b/src/pure_ext/csv.ts
@@ -22,7 +22,7 @@ export function csvEncode<T extends Record<keyof T, string | number | boolean>>(
 
 /**
 * Convert from CSV string to object array.
-* If cannot be parsed cell value, use default (`def`) value.
+* If parsing failed of cell value use default (`def`) value.
 * Convert to same type as default value.
 * @see https://deno.land/std/csv
 * @example
diff --git a/src/pure_ext/excel.ts b/src/pure_ext/excel.ts
index 9cc13ef..a97a136 100644
--- a/src/pure_ext/excel.ts
+++ b/src/pure_ext/excel.ts
@@ -1,7 +1,7 @@
-import {type WorkBook, type WorkSheet, type CellObject, xlsxcp, set_cptable, xlsxRead, xlsxWrite, xlsxUtil} from "../../deps.pure_ext.ts";
+import {type RawWorkBook, type RawWorkSheet, type RawWorkCell, xlsxcp, set_cptable, xlsxRead, xlsxWrite, xlsxUtil} from "../../deps.pure_ext.ts";
 import {deepClone} from "../pure/deep.ts";
 
-export type {WorkBook as RawWorkBook, WorkSheet as RawWorkSheet, CellObject as RawWorkCell};
+export type {RawWorkBook, RawWorkSheet, RawWorkCell};
 
 set_cptable(xlsxcp);
 
@@ -15,7 +15,7 @@ set_cptable(xlsxcp);
 * const enc = excelEncodeRaw(book);
 * ```
 */
-export function excelEncodeRaw(book:WorkBook, cp?:number, pw?:string):Uint8Array{
+export function excelEncodeRaw(book:RawWorkBook, cp?:number, pw?:string):Uint8Array{
     const buf = <ArrayBuffer>xlsxWrite(book, {
         type: "array",
         compression: true,
@@ -36,13 +36,13 @@ export function excelEncodeRaw(book:WorkBook, cp?:number, pw?:string):Uint8Array
 * ```
 */
 export function excelEncode(sheets:Record<string, string[][]>, cp?:number, pw?:string):Uint8Array{
-    const book:Record<string, WorkSheet> = {};
+    const book:Record<string, RawWorkSheet> = {};
 
     for(const [name, sheet] of Object.entries(sheets)){
-        const rows:CellObject[][] = [];
+        const rows:RawWorkCell[][] = [];
 
         for(const row of sheet){
-            const columns:CellObject[] = [];
+            const columns:RawWorkCell[] = [];
 
             for(const column of row){
                 columns.push({
@@ -76,7 +76,7 @@ export function excelEncode(sheets:Record<string, string[][]>, cp?:number, pw?:s
 * const enc = excelEncodeRaw(book);
 * ```
 */
-export function excelDecodeRaw(data:Uint8Array, cp?:number, pw?:string):WorkBook{
+export function excelDecodeRaw(data:Uint8Array, cp?:number, pw?:string):RawWorkBook{
     return xlsxRead(data, {
         type: "array",
         dense: true,
diff --git a/test/deno/path.test.ts b/test/deno/path.test.ts
index cfe63ad..e8399ee 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, homePath, mainPath} from "../../src/deno/path.ts";
+import {slashU, slashW, tmpPath, dataPath, configPath, homePath, mainPath} from "../../src/deno/path.ts";
 
 const {HOME, USERPROFILE} = Deno.env.toObject();
 const ep = `${fromFileUrl(dirname(Deno.mainModule))}/`;
@@ -21,6 +21,7 @@ Deno.test({
     fn(){
         assertEquals(tmpPath(), "C:/Windows/Temp");
         assertEquals(dataPath(), "C:/ProgramData");
+        assertEquals(configPath(), `${slashU(USERPROFILE)}/AppData/Roaming`);
         assertEquals(homePath(), slashU(USERPROFILE));
         assertEquals(mainPath(), slashU(ep));
     }
@@ -32,6 +33,7 @@ Deno.test({
     fn(){
         assertEquals(tmpPath(), "/tmp");
         assertEquals(dataPath(), "/var");
+        assertEquals(configPath(), `${HOME}/.config`);
         assertEquals(homePath(), HOME);
         assertEquals(mainPath(), ep);
     }
diff --git a/test/deno_ext/smtp.test.ts b/test/deno_ext/smtp.test.ts
index d5a4873..66e2ce3 100644
--- a/test/deno_ext/smtp.test.ts
+++ b/test/deno_ext/smtp.test.ts
@@ -10,7 +10,7 @@ Deno.test({
     async fn(){
         await smtpSend(cs, {
             from: em,
-            to: em,
+            to: [em],
             title: "CI Test",
             body: "CI Test"
         });
diff --git a/test/pure/crypto.test.ts b/test/pure/crypto.test.ts
index 6778939..ffa2499 100644
--- a/test/pure/crypto.test.ts
+++ b/test/pure/crypto.test.ts
@@ -38,15 +38,15 @@ Deno.test({
         const key1 = await pkGenerateECDH();
         const key2 = await pkGenerateECDH();
 
-        const encrypt = await pkEncrypt({
+        const encrypt = await pkEncrypt(sample, {
             publicKey: key1.publicKey,
             privateKey: key2.privateKey
-        }, sample);
+        });
 
-        const decrypt = await pkDecrypt({
+        const decrypt = await pkDecrypt(encrypt, {
             publicKey: key2.publicKey,
             privateKey: key1.privateKey
-        }, encrypt);
+        });
 
         assertEquals(decrypt, sample);
     }
@@ -56,8 +56,8 @@ Deno.test({
     name: "Crypto: Sign and Verify",
     async fn(){
         const key = await pkGenerateECDSA();
-        const signature = await pkSign(key.privateKey, sample);
-        const verify = await pkVerify(key.publicKey, signature, sample);
+        const signature = await pkSign(sample, key.privateKey);
+        const verify = await pkVerify(sample, key.publicKey, signature);
 
         assertEquals(verify, true);
     }
diff --git a/test/pure/text.test.ts b/test/pure/text.test.ts
index 7deb100..8ea62c8 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, sjisDecode, hexEncode, hexDecode, trimExtend, fixWidth, cleanText, accurateSegment, pad0} from "../../src/pure/text.ts";
+import {u8Encode, u8Decode, textDecode, hexEncode, hexDecode, trimExtend, fixWidth, cleanText, accurateSegment, pad0} from "../../src/pure/text.ts";
 
 const sampleText = "  Lorem ipsum\r dolor   sit  \r\r amet. ";
 const sampleBin = new Uint8Array([
@@ -23,9 +23,9 @@ Deno.test({
 });
 
 Deno.test({
-    name: "Text: SHIFT-JIS Decode",
+    name: "Text: Any Text Decode",
     fn(){
-        const decode = sjisDecode(sjisBin);
+        const decode = textDecode(sjisBin);
 
         assertEquals(decode, "こんにちは");
     }
diff --git a/test/pure/time.test.ts b/test/pure/time.test.ts
index 4349584..8b3b5b1 100644
--- a/test/pure/time.test.ts
+++ b/test/pure/time.test.ts
@@ -26,6 +26,8 @@ Deno.test({
     name: "Time: Delay",
     async fn(){
         await delay(100);
+
+        assertEquals(true, true);
     }
 });