diff --git a/CHANGELOG.md b/CHANGELOG.md
index 48e4b65..de0df34 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,71 @@
 # Changelog
 
+## [0.4.3](https://github.com/JonDotsoy/ndate/compare/morgan-v0.4.2...morgan-v0.4.3) (2023-10-30)
+
+
+### Bug Fixes
+
+* upgrade types required on handler ([8e6f09c](https://github.com/JonDotsoy/ndate/commit/8e6f09c53f98cb16c0f10d434b2713620253a4a4))
+
+## [0.4.2](https://github.com/JonDotsoy/ndate/compare/morgan-v0.4.1...morgan-v0.4.2) (2023-10-30)
+
+
+### Miscellaneous Chores
+
+* release 0.4.2 ([849a115](https://github.com/JonDotsoy/ndate/commit/849a11512db14b587226190c4fbeec76c2e7eb4a))
+
+## [0.4.1](https://github.com/JonDotsoy/ndate/compare/morgan-v0.4.0-morgan...morgan-v0.4.1) (2023-10-30)
+
+
+### Features
+
+* unwrap handler ([ad75381](https://github.com/JonDotsoy/ndate/commit/ad7538179419017c0d2954546fbfdd986027e492))
+
+
+### Miscellaneous Chores
+
+* release 0.4.1 ([da20150](https://github.com/JonDotsoy/ndate/commit/da20150d8bbd5a543139b924036a14365672de71))
+
+## 0.4.0-morgan (2023-10-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* configure strategy release by release name
+
+### Features
+
+* add execution header on ndate ([4b1ba2f](https://github.com/JonDotsoy/ndate/commit/4b1ba2fa5f22330f264046f046aacec40ebc531c))
+* Add flag --epoch, --epoch-ms and --time-zone ([c49ceac](https://github.com/JonDotsoy/ndate/commit/c49ceace5cb14d9c2ea3f836dc73d7c31d88a738))
+* add flag `--template` ([29fa11e](https://github.com/JonDotsoy/ndate/commit/29fa11e014e11bfd2f4e890906c6834fad47d127))
+* add new flags to the template ([b85b5c9](https://github.com/JonDotsoy/ndate/commit/b85b5c9e7b43f6dab427912a578e006b4f98ae99))
+* add support orender on sheet date ([a83a598](https://github.com/JonDotsoy/ndate/commit/a83a598f2d11d7d02b7c10741011a0d48cbada0a))
+* configure executable script ([c6e5ae1](https://github.com/JonDotsoy/ndate/commit/c6e5ae12ce7d8debc762f721f0749658710104d8))
+* configure utc flag ([42e3ade](https://github.com/JonDotsoy/ndate/commit/42e3adece8f984f4e8423338aef625b9c186bb34))
+* initial commit ([c52bd93](https://github.com/JonDotsoy/ndate/commit/c52bd93256a4124e7399204ff67a9c0145d5f578))
+* initialize version ([d59c863](https://github.com/JonDotsoy/ndate/commit/d59c86395e428ee0b072877943ae7036581593dd))
+* rename main function per setup ([b4d8675](https://github.com/JonDotsoy/ndate/commit/b4d86755ce7cd38526bd90c723a6720d9cb9813d))
+* upgrade ndate command ([4c198f1](https://github.com/JonDotsoy/ndate/commit/4c198f1fef1bb02dbe1676eeec93d28d2ad0075e))
+* upgrade template and permisions ([c9e767a](https://github.com/JonDotsoy/ndate/commit/c9e767ae35860b8b001f22337f7e997701995afe))
+
+
+### Bug Fixes
+
+* alias template to Hour, Minute, Second and Millisecond. ([b7a87d7](https://github.com/JonDotsoy/ndate/commit/b7a87d7118f86b1467df3a472f9746a3d4ea655f))
+* fix the padding start of the `{{ms}}` flag with a length of 3 ([a1733cf](https://github.com/JonDotsoy/ndate/commit/a1733cf52e99c8e5972f4244f651545d9047852e))
+* upgrade values to  and ([8896c75](https://github.com/JonDotsoy/ndate/commit/8896c75ff36e52e315c75d5d89e0fa62f6a3eb5e))
+
+
+### Miscellaneous Chores
+
+* release 0.4.0-alpha ([8d7039e](https://github.com/JonDotsoy/ndate/commit/8d7039e668904bc04a5710ff38636848776a6c66))
+* release 0.4.0-morgan ([72a7460](https://github.com/JonDotsoy/ndate/commit/72a746054195df482f745f85351b5e0260908ce0))
+
+
+### Build System
+
+* configure strategy release by release name ([385d77d](https://github.com/JonDotsoy/ndate/commit/385d77d3b5527ff03efe033758dff23705e65d0f))
+
 ## [0.3.0](https://github.com/JonDotsoy/ndate/compare/v0.2.9...v0.3.0) (2023-07-22)
 
 
diff --git a/README.md b/README.md
index 68a6ed4..4fb348c 100644
--- a/README.md
+++ b/README.md
@@ -3,22 +3,23 @@
 Date format to console.
 
 ```shell
-Usage: ndate [-] [--zero] [--date-style <full|long|medium|short|none>] [--time-style <full|long|medium|short|none>]
-             [--hour-cycles <h11|h12|h23|h24|none>] [--time-zone <time-zone>] [--local <locale>]
-             [--template <template>] [--json] [--utc] [--epoch] [--epoch-ms] [--date <date>]
-             [--help] [-j] [-d <date>] [-l <locale>] [-tz <time-zone>] [-z] [-h]
+Usage: ndate [-] [--date <date>] [-d <date>] [--date-style <full|long|medium|short|none>]
+             [--time-style <full|long|medium|short|none>] [--hour-cycles <h11|h12|h23|h24|none>]
+             [--time-zone <time-zone>] [-tz <time-zone>] [--local <locale>] [-l <locale>]
+             [--template <template>] [--json] [-j] [--sheet] [--utc] [--epoch] [--epoch-ms]
+             [--help] [-h] [--zero] [-z]
 ```
 
 Install with [homebrew](https://brew.sh/):
 
 ```shell
-brew install jondotsoy/ndate/ndate
+brew install jondotsoy/ndate/ndate@0.4
 ```
 
 Or install with deno:
 
 ```shell
-deno install --allow-env=TZ,LANG https://deno.land/x/ndate/ndate.ts
+deno install --allow-env=TZ,LANG https://deno.land/x/ndate@morgan-v0.4.3/ndate.ts
 ```
 
 Samples use:
@@ -38,6 +39,7 @@ ndate --epoch-ms # 1689255823663
 ndate --epoch-ms -z # 1689255823663%
 ndate --template '{{utc_full_year}}-{{utc_month:padStart:2:0}}-{{utc_date:padStart:2:0}}' # 2023-06-13
 ndate --template '{{YYYY}}{{MM}}{{DD}}{{HH}}{{MM}}{{SS}}{{MS}}' # 202330142030590781
+ndate --sheet # =DATE(2023;10;28)+TIME(1;17;12)
 ```
 
 ## Options to `--template`
diff --git a/__snapshots__/ndate.spec.ts.snap b/__snapshots__/ndate.spec.ts.snap
index d02ac0f..3f6b499 100644
--- a/__snapshots__/ndate.spec.ts.snap
+++ b/__snapshots__/ndate.spec.ts.snap
@@ -1,14 +1,120 @@
 export const snapshot = {};
 
 snapshot[`show help 1`] = `
-"Usage: ndate [-] [--zero] [--date-style <full|long|medium|short|none>] [--time-style <full|long|medium|short|none>]
+"Usage: ndate [-] [--date <date>] [-d <date>] [--date-style <full|long|medium|short|none>]
 " +
-  "             [--hour-cycles <h11|h12|h23|h24|none>] [--time-zone <time-zone>] [--local <locale>]
+  "             [--time-style <full|long|medium|short|none>] [--hour-cycles <h11|h12|h23|h24|none>]
 " +
-  "             [--template <template>] [--json] [--utc] [--epoch] [--epoch-ms] [--date <date>]
+  "             [--time-zone <time-zone>] [-tz <time-zone>] [--local <locale>] [-l <locale>]
 " +
-  "             [--help] [-j] [-d <date>] [-l <locale>] [-tz <time-zone>] [-z] [-h]
+  "             [--template <template>] [--json] [-j] [--sheet] [--utc] [--epoch] [--epoch-ms]
+" +
+  "             [--help] [-h] [--zero] [-z]
 "
 `;
 
-snapshot[`render date 1`] = `"miércoles, 13 de diciembre de 2023, 00:00:00 hora de verano de Chile"`;
+snapshot[`render date 1`] = `"miércoles, 13 de diciembre de 2023, 01:00:00 hora de verano de Chile"`;
+
+snapshot[`format json 1`] = `"2023-08-08T03:38:58.570Z"`;
+
+snapshot[`format utc 1`] = `"Tue, 08 Aug 2023 03:38:58 GMT"`;
+
+snapshot[`format epoch 1`] = `"1691465938"`;
+
+snapshot[`format epoch ms 1`] = `"1691465938570"`;
+
+snapshot[`format sheet 1`] = `"=DATE(2023;8;7)+TIME(23;38;58)"`;
+
+snapshot[`format template 1`] = `
+"epoch:1691465938
+" +
+  "epoch_ms:1691465938570
+" +
+  "json:2023-08-08T03:38:58.570Z
+" +
+  "iso:2023-08-08T03:38:58.570Z
+" +
+  "iso8601:2023-08-08T03:38:58.570Z
+" +
+  "utc:Tue, 08 Aug 2023 03:38:58 GMT
+" +
+  "rfc7231:Tue, 08 Aug 2023 03:38:58 GMT
+" +
+  "local:lunes, 7 de agosto de 2023, 23:38:58 hora estándar de Chile
+" +
+  "time:1691465938570
+" +
+  "YYYY:2023
+" +
+  "MM:08
+" +
+  "DD:07
+" +
+  "hh:23
+" +
+  "mm:38
+" +
+  "ss:58
+" +
+  "ms:570
+" +
+  "full_year:2023
+" +
+  "month:8
+" +
+  "date:7
+" +
+  "day:1
+" +
+  "hours:23
+" +
+  "minutes:38
+" +
+  "seconds:58
+" +
+  "milliseconds:570
+" +
+  "timezone_offset:240
+" +
+  "utc_full_year:2023
+" +
+  "utc_month:8
+" +
+  "utc_date:8
+" +
+  "utc_day:2
+" +
+  "utc_hours:3
+" +
+  "utc_minutes:38
+" +
+  "utc_seconds:58
+" +
+  "utc_milliseconds:570
+" +
+  "local_weekday:lunes
+" +
+  "local_literal: 
+" +
+  "local_day:7
+" +
+  "local_month:agosto
+" +
+  "local_year:2023
+" +
+  "local_hour:23
+" +
+  "local_minute:38
+" +
+  "local_second:58
+" +
+  "local_timeZoneName:hora estándar de Chile"
+`;
+
+snapshot[`format template with transform 1`] = `'"Tue, 08 Aug 2023 03:38:58 GMT"'`;
+
+snapshot[`format template with transform 2`] = `"Tue"`;
+
+snapshot[`format template with transform 3`] = `"0008"`;
+
+snapshot[`format template with transform 4`] = `"8000"`;
diff --git a/handler.ts b/handler.ts
index 5b6d876..1bfd64f 100644
--- a/handler.ts
+++ b/handler.ts
@@ -1,70 +1,129 @@
-import { 
-    toDateStyle,
-    toTimeStyle,
-    dateParse,
-toHourCycle,
- } from "./lib/common.ts";
+import {
+  dateParse,
+  toDateStyle,
+  toHourCycle,
+  toTimeStyle,
+} from "./lib/common.ts";
 import { renderDateTemplate } from "./lib/renderDateTemplate.ts";
 import { makeFlags } from "./makeFlags.ts";
 
-export const handler = async function*(args: string[]): AsyncGenerator<Uint8Array> {
-  let {
-    hourCycle, dateStyle, timeStyle, insertFinalNewLine, local, timeZone, date, outputAsEpoch, outputAsEpochMS, outputAsJSON, outputAsUTC, stdinReadable, showHelp, template, transformOptions, optionsLabels,
-  } = makeFlags(args);
+const renderSheet = (date: Date) => {
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1;
+  const dayOfMonth = date.getDate();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = date.getSeconds();
+  return `=DATE(${year};${month};${dayOfMonth})+TIME(${hours};${minutes};${seconds})`;
+};
 
-  if(showHelp) {
-    const items = Object.keys(transformOptions)
-      .map(item => {
-        const label = optionsLabels[item]?.label;
-        return label ? `[${item} ${label}]` : `[${item}]`;
-      });
+const makeHelpDialog = function* (
+  transformOptions: Record<
+    string,
+    unknown
+  >,
+  optionsLabels: Record<
+    string,
+    {
+      label?: string | undefined;
+    } | undefined
+  >,
+) {
+  const items = Object.keys(transformOptions)
+    .map((item) => {
+      const label = optionsLabels[item]?.label;
+      return label ? `[${item} ${label}]` : `[${item}]`;
+    });
 
-    const textUsage = `Usage: ndate`;
+  const textUsage = `Usage: ndate`;
 
-    const lines: string[] = [];
-    let currentLine: string | undefined;
-    for(const item of items) {
-      if(!currentLine) {
-        currentLine = lines.length ? `${' '.repeat(textUsage.length)}` : `${textUsage}`;
-      }
+  const lines: string[] = [];
+  let currentLine: string | undefined;
+  for (const item of items) {
+    if (!currentLine) {
+      currentLine = lines.length
+        ? `${" ".repeat(textUsage.length)}`
+        : `${textUsage}`;
+    }
 
-      currentLine = `${currentLine} ${item}`;
-      if(currentLine.length > 80) {
-        lines.push(currentLine);
-        currentLine = undefined;
-      }
+    currentLine = `${currentLine} ${item}`;
+    if (currentLine.length > 80) {
+      lines.push(currentLine);
+      currentLine = undefined;
     }
+  }
 
-    if(currentLine) lines.push(currentLine);
+  if (currentLine) lines.push(currentLine);
 
-    for(const line of lines) {
-      yield new TextEncoder().encode(line);
-      yield new TextEncoder().encode('\n');
-    }
+  for (const line of lines) {
+    yield new TextEncoder().encode(line);
+    yield new TextEncoder().encode("\n");
+  }
+};
 
+export const handler = async function* (
+  args: string[],
+): AsyncGenerator<Uint8Array> {
+  let {
+    hourCycle,
+    dateStyle,
+    timeStyle,
+    insertFinalNewLine,
+    local,
+    timeZone,
+    date,
+    outputAsEpoch,
+    outputAsEpochMS,
+    outputAsJSON,
+    outputAsUTC,
+    stdinReadable,
+    showHelp,
+    template,
+    transformOptions,
+    outputAsSheet,
+    optionsLabels,
+  } = makeFlags(args);
+
+  if (showHelp) {
+    yield* makeHelpDialog(transformOptions, optionsLabels);
     return;
   }
 
-  if(timeZone) Deno.env.set(`TZ`, timeZone);
-  if(local) Deno.env.set(`LANG`, local);
+  if (timeZone) Deno.env.set(`TZ`, timeZone);
+  if (local) Deno.env.set(`LANG`, local);
 
-  if(stdinReadable) {
+  if (stdinReadable) {
     const buff = new Uint8Array(256);
     await Deno.stdin.read(buff);
-    const text = new TextDecoder().decode(buff.subarray(0, buff.findIndex(p => p === 0))).trim();
+    const text = new TextDecoder().decode(
+      buff.subarray(0, buff.findIndex((p) => p === 0)),
+    ).trim();
     date = dateParse(text);
   }
 
   const toOutput = () => {
-    if(template) return renderDateTemplate(template, date, local, { dateStyle: toDateStyle(dateStyle), timeStyle: toTimeStyle(timeStyle), timeZone, hourCycle: toHourCycle(hourCycle) });
-    if(outputAsEpochMS) return Math.floor(date.getTime()).toString();
-    if(outputAsEpoch) return Math.floor(date.getTime() / 1000).toString();
-    if(outputAsJSON) return date.toJSON();
-    if(outputAsUTC) return date.toUTCString();
-    return date.toLocaleString(local, { dateStyle: toDateStyle(dateStyle), timeStyle: toTimeStyle(timeStyle), timeZone, hourCycle: toHourCycle(hourCycle) });
+    if (template) {
+      return renderDateTemplate(template, date, local, {
+        dateStyle: toDateStyle(dateStyle),
+        timeStyle: toTimeStyle(timeStyle),
+        timeZone,
+        hourCycle: toHourCycle(hourCycle),
+      });
+    }
+    if (outputAsEpochMS) return Math.floor(date.getTime()).toString();
+    if (outputAsEpoch) return Math.floor(date.getTime() / 1000).toString();
+    if (outputAsJSON) return date.toJSON();
+    if (outputAsUTC) return date.toUTCString();
+    if (outputAsSheet) return renderSheet(date);
+    return date.toLocaleString(local, {
+      dateStyle: toDateStyle(dateStyle),
+      timeStyle: toTimeStyle(timeStyle),
+      timeZone,
+      hourCycle: toHourCycle(hourCycle),
+    });
   };
 
   yield new TextEncoder().encode(toOutput());
 
-  if(insertFinalNewLine) yield new TextEncoder().encode(`\n`);
+  if (insertFinalNewLine) yield new TextEncoder().encode(`\n`);
 };
diff --git a/lib/crontab-parse.spec.ts b/lib/crontab-parse.spec.ts
new file mode 100644
index 0000000..2a92540
--- /dev/null
+++ b/lib/crontab-parse.spec.ts
@@ -0,0 +1,192 @@
+import {
+  assertArrayIncludes,
+  assertEquals,
+  assertInstanceOf,
+  assertObjectMatch,
+} from "https://deno.land/std@0.204.0/assert/mod.ts";
+import { astCrontabParse } from "./crontab-parse.ts";
+
+Deno.test("Parse AST", () => {
+  assertEquals(
+    astCrontabParse("* * * * *"),
+    {
+      type: "Statement",
+      start: 0,
+      end: 9,
+      body: [
+        {
+          type: 'AnyValue',
+          start: 0,
+          end: 1,
+        },
+        {
+          end: 3,
+          start: 2,
+          type: "AnyValue",
+        },
+        {
+          end: 5,
+          start: 4,
+          type: "AnyValue",
+        },
+        {
+          end: 7,
+          start: 6,
+          type: "AnyValue",
+        },
+        {
+          end: 9,
+          start: 8,
+          type: "AnyValue",
+        },
+      ]
+    }
+  )
+})
+
+Deno.test("Parse AST", () => {
+  assertEquals(
+    astCrontabParse("1 * * * *").body.at(0),
+    {
+      type: 'NumberValue',
+      start: 0,
+      end: 1,
+      value: 1
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1,2,3,4 * * * *"),
+    {
+      body: [{
+        values: [
+          { type: 'NumberValue', value: 1 },
+          { type: 'NumberValue', value: 2 },
+          { type: 'NumberValue', value: 3 },
+          { type: 'NumberValue', value: 4 },
+        ]
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1,2,3,4 * * * *"),
+    {
+      body: [{
+        values: [
+          { type: 'NumberValue', value: 1 },
+          { type: 'NumberValue', value: 2 },
+          { type: 'NumberValue', value: 3 },
+          { type: 'NumberValue', value: 4 },
+        ]
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1,2,3,4 * * * *"),
+    {
+      body: [{
+        type: 'ListValue',
+        values: [
+          { type: 'NumberValue', value: 1 },
+          { type: 'NumberValue', value: 2 },
+          { type: 'NumberValue', value: 3 },
+          { type: 'NumberValue', value: 4 },
+        ]
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1 * * * *"),
+    {
+      body: [{
+        type: 'NumberValue',
+        value: 1
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1/2 * * * *"),
+    {
+      body: [{
+        type: 'StepValue',
+        left: { type: "NumberValue", value: 1 },
+        right: { type: "NumberValue", value: 2 },
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1-2 * * * *"),
+    {
+      body: [{
+        type: 'RangeValue',
+        left: {
+          type: 'NumberValue',
+          value: 1
+        },
+        right: {
+          type: 'NumberValue',
+          value: 2
+        }
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("1-2/3 * * * *"),
+    {
+      body: [{
+        type: 'StepValue',
+        left: {
+          type: 'RangeValue',
+          left: {
+            type: 'NumberValue',
+            value: 1
+          },
+          right: {
+            type: 'NumberValue',
+            value: 2
+          }
+        },
+        right: {
+          type: 'NumberValue',
+          value: 3
+        }
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("4,1-2/3 * * * *"),
+    {
+      body: [{
+        type: "ListValue",
+        values: [
+          {
+            type: "NumberValue",
+            value: 4
+          },
+          {
+            type: 'StepValue',
+            left: {
+              type: 'RangeValue',
+              left: {
+                type: 'NumberValue',
+                value: 1
+              },
+              right: {
+                type: 'NumberValue',
+                value: 2
+              }
+            },
+            right: {
+              type: 'NumberValue',
+              value: 3
+            }
+          }
+        ]
+      }]
+    }
+  );
+  assertObjectMatch(
+    astCrontabParse("* * * jan *"),
+    { body: [{}, {}, {}, { value: 1 }] },
+  );
+  astCrontabParse("1,2-43,1/3,1-2/53 1,2-13,1/3,1-2/9 1,2-13,1/3,1-2/9 1,2-jun,1/3,1-2/9 1,2-4,1/3,1-2/3")
+})
diff --git a/lib/crontab-parse.ts b/lib/crontab-parse.ts
new file mode 100644
index 0000000..7acbc20
--- /dev/null
+++ b/lib/crontab-parse.ts
@@ -0,0 +1,332 @@
+type Expression = {
+  start: number
+  end: number
+}
+
+type AnyValueExpression = { type: "AnyValue" } & Expression
+type NumberValueExpression = { type: "NumberValue", value: number } & Expression
+type ListItemExpression = { type: "ListItemValue", value: string } & Expression
+type ListValueExpression = { type: "ListValue", values: MathExpression[] } & Expression
+type StepValueExpression = { type: "StepValue", left: MathExpression, right: MathExpression } & Expression
+type RangeValueExpression = { type: "RangeValue", left: MathExpression, right: MathExpression } & Expression
+
+type MathExpression = AnyValueExpression | NumberValueExpression | ListValueExpression | StepValueExpression | RangeValueExpression
+
+type StatementExpression = {
+  type: "Statement"
+  body: MathExpression[]
+} & Expression
+
+type ExpressionPart = Expression & {
+  body: string
+}
+
+function* eachExpressionPart(body: string): Generator<ExpressionPart> {
+  const exp = /\s+/g
+  let res: null | RegExpExecArray = null
+
+  let nextStart = 0
+  while ((res = exp.exec(body)) !== null) {
+    yield {
+      start: nextStart,
+      end: res.index,
+      body: body.substring(nextStart, res.index)
+    }
+    nextStart = res.index + res[0].length
+  }
+  yield {
+    start: nextStart,
+    end: body.length,
+    body: body.substring(nextStart, body.length)
+  }
+}
+
+type TestExpressionPart = (expressionPart: ExpressionPart) => MathExpression | null
+
+const AnyValueExpressionPartParse: TestExpressionPart = (expressionPart: ExpressionPart): MathExpression | null => expressionPart.body === '*' ? { type: 'AnyValue', start: expressionPart.start, end: expressionPart.end } : null
+
+const toNumber = (value: unknown, enumList?: (string | null)[]): null | number => {
+  if (typeof value !== 'string') return null
+  if (/^\d+$/.test(value)) return Number(value)
+  if (enumList) {
+    let n = -1
+    for (const match of enumList) {
+      n += 1
+      if (match?.toLowerCase() === value.toLowerCase()) {
+        return n
+      }
+    }
+  }
+  return null
+}
+
+const NumberValueExpressionPartParse = (start?: number, end?: number, enumList?: (null | string)[]): TestExpressionPart => (expressionPart: ExpressionPart): MathExpression | null => {
+  const num = toNumber(expressionPart.body, enumList)
+  if (num === null) return null;
+  if (start !== undefined && num < start) return null
+  if (end !== undefined && num > end) return null
+  return { type: 'NumberValue', start: expressionPart.start, end: expressionPart.end, value: num };
+}
+
+const RangeValueExpressionPartParse = (leftTestExpressionPart: TestExpressionPart, rightTestExpressionPart: TestExpressionPart): TestExpressionPart => (expressionPart) => {
+  const expr = /^(.+)\-(.+)$/
+  const regExpExecArray = expr.exec(expressionPart.body)
+  if (!regExpExecArray) return null
+  const [, leftRaw, rightRaw] = regExpExecArray
+  const leftExpressionPart: ExpressionPart = {
+    body: leftRaw,
+    start: expressionPart.start,
+    end: expressionPart.start + leftRaw.length
+  }
+  const rightExpressionPart: ExpressionPart = {
+    body: rightRaw,
+    start: expressionPart.start + leftRaw.length + 1,
+    end: expressionPart.start + leftRaw.length + 1 + rightRaw.length
+  }
+  const left = leftTestExpressionPart(leftExpressionPart)
+  const right = rightTestExpressionPart(rightExpressionPart)
+
+  if (!left) throw new Error('Unexpected token', { cause: leftExpressionPart })
+  if (!right) throw new Error('Unexpected token', { cause: rightExpressionPart })
+
+  return {
+    type: 'RangeValue',
+    start: right!.start,
+    end: left!.end,
+    left,
+    right,
+  }
+}
+
+const StepValueExpressionPartParse = (leftTestExpressionPart: TestExpressionPart, rightTestExpressionPart: TestExpressionPart): TestExpressionPart => (expressionPart) => {
+  const expr = /^(.+)\/(.+)$/
+
+  const regExpExecArray = expr.exec(expressionPart.body)
+
+  if (regExpExecArray === null) return null
+
+  const leftExpressionPart: ExpressionPart = {
+    start: expressionPart.start,
+    end: expressionPart.start + regExpExecArray[1].length,
+    body: regExpExecArray[1],
+  }
+  const rightExpressionPart: ExpressionPart = {
+    start: expressionPart.start + regExpExecArray[1].length + 1,
+    end: expressionPart.start + regExpExecArray[1].length + 1 + regExpExecArray[2].length,
+    body: regExpExecArray[2],
+  }
+
+  const left = leftTestExpressionPart(leftExpressionPart)
+  const right = rightTestExpressionPart(rightExpressionPart)
+  if (!right) throw new Error(`Unexpected token`, { cause: rightExpressionPart })
+  if (!left) throw new Error(`Unexpected token`, { cause: leftExpressionPart })
+
+  return {
+    type: "StepValue",
+    left,
+    right,
+    start: left.start,
+    end: right.end,
+  }
+}
+
+function* splitTokens(body: string): Generator<ListItemExpression> {
+  const spl = /,/g
+
+  let res: null | RegExpExecArray = null
+  let start = 0
+  let end = 0
+  while ((res = spl.exec(body)) !== null) {
+    yield {
+      type: "ListItemValue",
+      start,
+      end,
+      value: body.substring(start, res.index)
+    }
+    start = res.index + 1
+  }
+
+  yield {
+    type: "ListItemValue",
+    start,
+    end: body.length,
+    value: body.substring(start, body.length)
+  }
+
+}
+
+const ListValuesExpressionPartParse = (allowTests: TestExpressionPart[]): TestExpressionPart => (expressionPart) => {
+  if (!/,/.test(expressionPart.body)) return null
+  return {
+    type: 'ListValue',
+    start: expressionPart.start,
+    end: expressionPart.end,
+    values: Array.from(
+      splitTokens(expressionPart.body),
+      item => matrixExpressionPart(allowTests)({
+        start: expressionPart.start + item.start,
+        end: expressionPart.start + item.end,
+        body: item.value
+      })
+    )
+  }
+}
+
+const matrixExpressionPart = (tests: TestExpressionPart[]) => (expressionPart: ExpressionPart): MathExpression => {
+  for (const test of tests) {
+    const res = test(expressionPart)
+    if (res) return res
+  }
+  throw new Error(`Unexpected token`, { cause: expressionPart })
+}
+
+namespace minuteExpressionPartParse {
+  export const number = NumberValueExpressionPartParse(0, 59)
+  export const any = AnyValueExpressionPartParse
+  export const range = RangeValueExpressionPartParse(number, number)
+  export const step = StepValueExpressionPartParse(
+    matrixExpressionPart([
+      number,
+      range,
+    ]),
+    number
+  )
+  export const list = ListValuesExpressionPartParse([
+    step,
+    range,
+    number,
+  ])
+
+  export const all = matrixExpressionPart([
+    list,
+    step,
+    range,
+    any,
+    number,
+  ])
+}
+
+namespace hourExpressionPartParse {
+  export const number = NumberValueExpressionPartParse(0, 23)
+  export const any = AnyValueExpressionPartParse
+  export const range = RangeValueExpressionPartParse(number, number)
+  export const step = StepValueExpressionPartParse(
+    matrixExpressionPart([
+      number,
+      range,
+    ]),
+    number
+  )
+  export const list = ListValuesExpressionPartParse([
+    step,
+    range,
+    number,
+  ])
+
+  export const all = matrixExpressionPart([
+    list,
+    step,
+    range,
+    any,
+    number,
+  ])
+}
+
+namespace dayOfMonthExpressionPartParse {
+  export const number = NumberValueExpressionPartParse(1, 31)
+  export const any = AnyValueExpressionPartParse
+  export const range = RangeValueExpressionPartParse(number, number)
+  export const step = StepValueExpressionPartParse(
+    matrixExpressionPart([
+      number,
+      range,
+    ]),
+    number
+  )
+  export const list = ListValuesExpressionPartParse([
+    step,
+    range,
+    number,
+  ])
+
+  export const all = matrixExpressionPart([
+    list,
+    step,
+    range,
+    any,
+    number,
+  ])
+}
+namespace monthExpressionPartParse {
+  export const number = NumberValueExpressionPartParse(1, 12, [null, 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
+  export const any = AnyValueExpressionPartParse
+  export const range = RangeValueExpressionPartParse(number, number)
+  export const step = StepValueExpressionPartParse(
+    matrixExpressionPart([
+      number,
+      range,
+    ]),
+    number
+  )
+  export const list = ListValuesExpressionPartParse([
+    step,
+    range,
+    number,
+  ])
+
+  export const all = matrixExpressionPart([
+    list,
+    step,
+    range,
+    any,
+    number,
+  ])
+}
+namespace dayOfWeekExpressionPartParse {
+  export const number = NumberValueExpressionPartParse(0, 6, ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'])
+  export const any = AnyValueExpressionPartParse
+  export const range = RangeValueExpressionPartParse(number, number)
+  export const step = StepValueExpressionPartParse(
+    matrixExpressionPart([
+      number,
+      range,
+    ]),
+    number
+  )
+  export const list = ListValuesExpressionPartParse([
+    step,
+    range,
+    number,
+  ])
+
+  export const all = matrixExpressionPart([
+    list,
+    step,
+    range,
+    any,
+    number,
+  ])
+}
+
+const parseMinuteExpressionPart = (expressionPart: ExpressionPart): MathExpression => minuteExpressionPartParse.all(expressionPart)
+const parseHourExpressionPart = (expressionPart: ExpressionPart): MathExpression => hourExpressionPartParse.all(expressionPart)
+const parseDayMonthExpressionPart = (expressionPart: ExpressionPart): MathExpression => dayOfMonthExpressionPartParse.all(expressionPart)
+const parseMonthExpressionPart = (expressionPart: ExpressionPart): MathExpression => monthExpressionPartParse.all(expressionPart)
+const parseDayWeekExpressionPart = (expressionPart: ExpressionPart): MathExpression => dayOfWeekExpressionPartParse.all(expressionPart)
+
+const parseExpressionPart = (expressionPart: ExpressionPart, index: number): MathExpression => {
+  const parser = [parseMinuteExpressionPart, parseHourExpressionPart, parseDayMonthExpressionPart, parseMonthExpressionPart, parseDayWeekExpressionPart].at(index)
+  if (!parser) throw new Error(`Unexpected token`, { cause: expressionPart })
+  return parser(expressionPart)
+}
+
+export const astCrontabParse = (body: string): StatementExpression => {
+  const parts = Array.from(eachExpressionPart(body), parseExpressionPart)
+
+  return {
+    type: "Statement",
+    start: 0,
+    end: body.length,
+    body: parts
+  }
+}
diff --git a/lib/makeFlags.spec.ts b/lib/makeFlags.spec.ts
new file mode 100644
index 0000000..63038a3
--- /dev/null
+++ b/lib/makeFlags.spec.ts
@@ -0,0 +1,168 @@
+import {
+  assertArrayIncludes,
+  assertEquals,
+  assertInstanceOf,
+  assertObjectMatch,
+} from "https://deno.land/std@0.204.0/assert/mod.ts";
+import { makeFlags as makeFlags2 } from "../makeFlags.ts";
+
+Deno.test("should parse zero argument", () => {
+  assertEquals(makeFlags2([]).insertFinalNewLine, true);
+  assertEquals(makeFlags2(["-z"]).insertFinalNewLine, false);
+  assertEquals(makeFlags2(["--zero"]).insertFinalNewLine, false);
+});
+
+Deno.test("should parse date argument", () => {
+  assertInstanceOf(makeFlags2([]).date, Date);
+  assertEquals(
+    makeFlags2(["-d", "2024-04-02T05:23:05Z"]).date.toJSON(),
+    "2024-04-02T05:23:05.000Z",
+  );
+  assertEquals(
+    makeFlags2(["--date", "2024-04-02T05:23:05Z"]).date.toJSON(),
+    "2024-04-02T05:23:05.000Z",
+  );
+});
+
+Deno.test("should parse help argument", () => {
+  assertEquals(makeFlags2([]).showHelp, false);
+  assertEquals(makeFlags2(["-h"]).showHelp, true);
+  assertEquals(makeFlags2(["--help"]).showHelp, true);
+});
+
+Deno.test("should parse date-style argument", () => {
+  assertEquals(makeFlags2([]).dateStyle, "full");
+  assertEquals(makeFlags2(["--date-style", "other"]).dateStyle, "none");
+  assertEquals(makeFlags2(["--date-style", "medium"]).dateStyle, "medium");
+});
+
+Deno.test("should parse time-style argument", () => {
+  assertEquals(makeFlags2([]).timeStyle, "full");
+  assertEquals(makeFlags2(["--time-style", "other"]).timeStyle, "none");
+  assertEquals(makeFlags2(["--time-style", "medium"]).timeStyle, "medium");
+});
+
+Deno.test("should parse hour-cycles argument", () => {
+  assertEquals(makeFlags2([]).hourCycle, "none");
+  assertEquals(makeFlags2(["--hour-cycles", "h23"]).hourCycle, "h23");
+  assertEquals(makeFlags2(["--hour-cycles", "h12"]).hourCycle, "h12");
+});
+
+Deno.test("should parse time-zone argument", () => {
+  assertEquals(makeFlags2([]).timeZone, undefined);
+  assertEquals(
+    makeFlags2(["--time-zone", "America/Santiago"]).timeZone,
+    "America/Santiago",
+  );
+  assertEquals(
+    makeFlags2(["-tz", "America/Santiago"]).timeZone,
+    "America/Santiago",
+  );
+});
+
+Deno.test("should parse local argument", () => {
+  assertEquals(makeFlags2([]).local, undefined);
+  assertEquals(makeFlags2(["--local", "es-CL"]).local, "es-CL");
+  assertEquals(makeFlags2(["-l", "es-CL"]).local, "es-CL");
+});
+
+Deno.test("should parse template argument", () => {
+  assertEquals(makeFlags2([]).template, undefined);
+  assertEquals(makeFlags2(["--template", "hello"]).template, "hello");
+});
+
+Deno.test("should parse json argument", () => {
+  assertEquals(makeFlags2([]).outputAsJSON, false);
+  assertEquals(makeFlags2(["--json"]).outputAsJSON, true);
+  assertEquals(makeFlags2(["-j"]).outputAsJSON, true);
+});
+
+Deno.test("should parse sheet argument", () => {
+  assertEquals(makeFlags2([]).outputAsSheet, false);
+  assertEquals(makeFlags2(["--sheet"]).outputAsSheet, true);
+});
+
+Deno.test("should parse utc argument", () => {
+  assertEquals(makeFlags2([]).outputAsUTC, false);
+  assertEquals(makeFlags2(["--utc"]).outputAsUTC, true);
+});
+
+Deno.test("should parse epoch argument", () => {
+  assertEquals(makeFlags2([]).outputAsEpoch, false);
+  assertEquals(makeFlags2(["--epoch"]).outputAsEpoch, true);
+});
+
+Deno.test("should parse epoch-ms argument", () => {
+  assertEquals(makeFlags2([]).outputAsEpochMS, false);
+  assertEquals(makeFlags2(["--epoch-ms"]).outputAsEpochMS, true);
+});
+
+Deno.test("should parse hyphen argument", () => {
+  assertEquals(makeFlags2([]).stdinReadable, false);
+  assertEquals(makeFlags2(["-"]).stdinReadable, true);
+});
+
+Deno.test("should get the transformOptions field", () => {
+  const s = Array.from(Object.keys(makeFlags2([]).transformOptions));
+
+  assertArrayIncludes(s, [
+    "-",
+    "--zero",
+    "--date-style",
+    "--time-style",
+    "--hour-cycles",
+    "--time-zone",
+    "--local",
+    "--template",
+    "--json",
+    "--sheet",
+    "--utc",
+    "--epoch",
+    "--epoch-ms",
+    "--date",
+    "--help",
+    "-j",
+    "-d",
+    "-l",
+    "-tz",
+    "-z",
+    "-h",
+  ]);
+});
+
+Deno.test("should get the optionsLabels field", () => {
+  const s = makeFlags2([]).optionsLabels;
+
+  assertObjectMatch(s, {
+    "--date": {
+      label: "<date>",
+    },
+    "-d": {
+      label: "<date>",
+    },
+    "--date-style": {
+      label: "<full|long|medium|short|none>",
+    },
+    "--hour-cycles": {
+      label: "<h11|h12|h23|h24|none>",
+    },
+    "--local": {
+      label: "<locale>",
+    },
+    "-l": {
+      label: "<locale>",
+    },
+    "--template": {
+      label: "<template>",
+    },
+    "--time-style": {
+      label: "<full|long|medium|short|none>",
+    },
+    "--time-zone": {
+      label: "<time-zone>",
+    },
+    "-tz": {
+      label: "<time-zone>",
+    },
+  });
+});
diff --git a/makeFlags.ts b/makeFlags.ts
index d8443ed..6649963 100644
--- a/makeFlags.ts
+++ b/makeFlags.ts
@@ -1,91 +1,138 @@
-import { 
-    dateStyles,
-    timeStyles,
-    DateStyle,
-    TimeStyle,
-    toDateStyleString,
-    toTimeStyleString,
-    dateParse,
-    hourCycles,
-toHourCycleString,
- } from "./lib/common.ts";
+import {
+  dateParse,
+  DateStyle,
+  dateStyles,
+  hourCycles,
+  TimeStyle,
+  timeStyles,
+  toDateStyleString,
+  toHourCycleString,
+  toTimeStyleString,
+} from "./lib/common.ts";
+import {
+  describe,
+  flag,
+  flags,
+  Handler,
+  isBooleanAt,
+  isStringAt,
+  Rule,
+  Test,
+} from "npm:@jondotsoy/flags@2.0.2";
 
-export function makeFlags(args: string[]) {
-  let hourCycle: (typeof hourCycles)[number] = 'none';
-  let dateStyle: DateStyle = 'full';
-  let timeStyle: TimeStyle = 'full';
-  let insertFinalNewLine = true;
-  let local: string | undefined;
-  let timeZone: string | undefined;
-  let date = new Date();
-  let outputAsEpoch = false;
-  let outputAsEpochMS = false;
-  let outputAsJSON = false;
-  let outputAsUTC = false;
-  let stdinReadable = false;
-  let showHelp = false;
-  let template: string | undefined;
-  let crontab: string | undefined;
+const labelSymbol = Symbol("label");
 
-  const transformOptions: Record<string, (nextArgument: () => string | undefined) => void> = {
-    '-': () => { stdinReadable = true; },
-    '--zero': () => { insertFinalNewLine = false; },
-    '--date-style': (nextArgument) => { dateStyle = toDateStyleString(nextArgument()); },
-    '--time-style': (nextArgument) => { timeStyle = toTimeStyleString(nextArgument()); },
-    '--hour-cycles': (nextArgument) => { hourCycle = toHourCycleString(nextArgument()) },
-    '--time-zone': (nextArgument) => { timeZone = nextArgument(); },
-    '--local': (nextArgument) => { local = nextArgument(); },
-    '--template': (nextArgument) => { template = nextArgument(); },
-    '--json': () => { outputAsJSON = true; },
-    '--utc': () => { outputAsUTC = true; },
-    '--epoch': () => { outputAsEpoch = true; },
-    '--epoch-ms': () => { outputAsEpochMS = true; },
-    '--date': (nextArgument) => {
-      const v = nextArgument();
-      if(v) {
-        date = dateParse(v);
-      }
-    },
-    '--help': () => { showHelp = true; },
-    get "-j"() { return this['--json']; },
-    get "-d"() { return this["--date"]; },
-    get "-l"() { return this["--local"]; },
-    get "-tz"() { return this["--time-zone"]; },
-    get "-z"() { return this["--zero"]; },
-    get "-h"() { return this["--help"]; },
-  };
+const setLabel = (obj: object, label: string) =>
+  Reflect.set(obj, labelSymbol, label);
+const getLabel = (obj: object) => Reflect.get(obj, labelSymbol);
+
+const describeLabel = (test: Test<any>, label: string): Test<any> => {
+  setLabel(test, label);
+  return test;
+};
+
+interface Options {
+  hourCycle: (typeof hourCycles)[number];
+  dateStyle: DateStyle;
+  timeStyle: TimeStyle;
+  insertFinalNewLine: boolean;
+  local: string;
+  timeZone: string;
+  date: Date;
+  outputAsEpoch: boolean;
+  outputAsEpochMS: boolean;
+  outputAsJSON: boolean;
+  outputAsUTC: boolean;
+  outputAsSheet: boolean;
+  stdinReadable: boolean;
+  showHelp: boolean;
+  template: string;
+  crontab: string;
+}
 
-  const optionsLabels: Record<string, undefined | { label?: string; }> = {
-    '--date-style': { label: `<${dateStyles.join('|')}>` },
-    '--time-style': { label: `<${timeStyles.join('|')}>` },
-    '--hour-cycles': { label: `<${hourCycles.join('|')}>` },
-    '--local': { label: `<locale>` },
-    '--date': { label: `<date>` },
-    '--template': { label: `<template>` },
-    '--time-zone': { label: `<time-zone>` },
-    get "-j"() { return this['--json']; },
-    get "-d"() { return this["--date"]; },
-    get "-l"() { return this["--local"]; },
-    get "-tz"() { return this["--time-zone"]; },
-    get "-z"() { return this["--zero"]; },
-    get "-h"() { return this["--help"]; },
+const isArgumentTransformAt =
+  (field: string, transform: (v: string) => unknown): Handler<any> => (o) => {
+    const value = o.argValue ?? o.args[o.index + 1];
+    if (value) {
+      o.nextIndex += 1;
+      o.flags[field] = transform(value);
+    }
   };
 
-  const parseCrontab = (str: string) => {
-    const res = /^((?<predefined>@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(?<every>@every ((?<every_value>\d+)(?<every_value_sign>ns|us|µs|ms|s|m|h))+)|(?<cron>(?<cron_minute>((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*)) (?<cron_hour>((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*)) (?<cron_day_month>((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*)) (?<cron_month>((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*)) (?<cron_day_week>((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*))))$/.exec(str);
+export function makeFlags(args: string[]) {
+  const rules: Rule<Options>[] = [
+    [flag("-"), isBooleanAt("stdinReadable")],
+    [
+      describeLabel(flag("--date", "-d"), "<date>"),
+      isArgumentTransformAt("date", dateParse),
+    ],
+    [
+      describeLabel(flag("--date-style"), `<${dateStyles.join("|")}>`),
+      isArgumentTransformAt("dateStyle", toDateStyleString),
+    ],
+    [
+      describeLabel(flag("--time-style"), `<${timeStyles.join("|")}>`),
+      isArgumentTransformAt("timeStyle", toTimeStyleString),
+    ],
+    [
+      describeLabel(flag("--hour-cycles"), `<${hourCycles.join("|")}>`),
+      isArgumentTransformAt("hourCycle", toHourCycleString),
+    ],
+    [
+      describeLabel(flag("--time-zone", "-tz"), "<time-zone>"),
+      isStringAt("timeZone"),
+    ],
+    [describeLabel(flag("--local", "-l"), "<locale>"), isStringAt("local")],
+    [describeLabel(flag("--template"), "<template>"), isStringAt("template")],
+    [flag("--json", "-j"), isBooleanAt("outputAsJSON")],
+    [flag("--sheet"), isBooleanAt("outputAsSheet")],
+    [flag("--utc"), isBooleanAt("outputAsUTC")],
+    [flag("--epoch"), isBooleanAt("outputAsEpoch")],
+    [flag("--epoch-ms"), isBooleanAt("outputAsEpochMS")],
+    [flag("--help", "-h"), isBooleanAt("showHelp")],
+    [
+      flag("--zero", "-z"),
+      ({ flags }) => Reflect.set(flags, "insertFinalNewLine", false),
+    ],
+  ];
 
-    if(!res) return null;
+  const {
+    hourCycle = "none",
+    dateStyle = "full",
+    timeStyle = "full",
+    insertFinalNewLine = true,
+    date = new Date(),
+    outputAsEpoch = false,
+    outputAsEpochMS = false,
+    outputAsJSON = false,
+    outputAsUTC = false,
+    outputAsSheet = false,
+    stdinReadable = false,
+    showHelp = false,
+    local,
+    timeZone,
+    template,
+    crontab,
+  } = flags<Options>(args, {}, rules);
 
-    if(res.groups?.predefined)
-      return {
-        predefined: res.groups.predefined
-      };
-  };
+  const {
+    transformOptions,
+    optionsLabels,
+  } = rules.reduce((acc, rule) => {
+    const [test] = rule;
+
+    const withLabel = getLabel(test);
+
+    for (const name of test.names ?? []) {
+      Reflect.set(acc.transformOptions, name, null);
+      Reflect.set(acc.optionsLabels, name, { label: withLabel });
+    }
 
-  for(let argsCursor = args[Symbol.iterator](), { value: arg, done } = argsCursor.next();!done;{ value: arg, done } = argsCursor.next()) {
-    const next = (): string | undefined => argsCursor.next().value;
-    if(typeof arg === "string" && arg in transformOptions) { transformOptions[arg](next); }
-  }
+    return acc;
+  }, {
+    transformOptions: {} as Record<string, null>,
+    optionsLabels: {} as Record<string, { label?: string } | undefined>,
+  });
 
   return {
     hourCycle,
@@ -99,6 +146,7 @@ export function makeFlags(args: string[]) {
     outputAsEpochMS,
     outputAsJSON,
     outputAsUTC,
+    outputAsSheet,
     stdinReadable,
     showHelp,
     template,
diff --git a/ndate.spec.ts b/ndate.spec.ts
index b53c9ff..d099374 100644
--- a/ndate.spec.ts
+++ b/ndate.spec.ts
@@ -1,15 +1,21 @@
 import { assertSnapshot } from "https://deno.land/std@0.195.0/testing/snapshot.ts";
 import { handler } from "./handler.ts";
 
-const joinUint8ArrayGenerator = async (
-  generator: AsyncGenerator<Uint8Array>,
-) => {
-  let buffEnd = new Uint8Array();
-  for await (const line of generator) {
-    buffEnd = new Uint8Array([...buffEnd, ...line]);
+const ArrayFromAsync = async <T, R = T>(iterator: AsyncIterable<T>, mapFn?: (element: T, index: number) => R, thisArg?: any): Promise<R[]> => {
+  const items: R[] = []
+  let index = -1
+  for await (const item of iterator) {
+    index = index + 1
+    items.push(mapFn?.call(thisArg, item, index) ?? item as R)
   }
-  return buffEnd;
-};
+  return items
+}
+
+const joinUint8ArrayGenerator = async (
+  generator: AsyncIterable<Uint8Array>,
+) => new Uint8Array(
+  (await ArrayFromAsync(generator, e => [...e])).flat()
+);
 
 Deno.test("show help", async (t) => {
   await assertSnapshot(
@@ -27,8 +33,216 @@ Deno.test("render date", async (t) => {
     t,
     new TextDecoder().decode(
       await joinUint8ArrayGenerator(
-        handler(["-z", "-d", "2023-12-13 00:00","-l","es-cl",'-tz',"America/Santiago"]),
+        handler(["-z", "-d", "2023-12-13 00:00", "-l", "es-cl", '-tz', "America/Santiago"]),
       ),
     ),
   );
 });
+
+Deno.test("format json", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--json'
+        ]),
+      ),
+    ),
+  );
+})
+
+Deno.test("format utc", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--utc'
+        ]),
+      ),
+    ),
+  );
+})
+
+Deno.test("format epoch", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--epoch'
+        ]),
+      ),
+    ),
+  );
+})
+
+
+Deno.test("format epoch ms", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--epoch-ms'
+        ]),
+      ),
+    ),
+  );
+})
+
+
+Deno.test("format sheet", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--sheet'
+        ]),
+      ),
+    ),
+  );
+})
+
+
+Deno.test("format template", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--template',
+          'epoch:{{epoch}}\nepoch_ms:{{epoch_ms}}\njson:{{json}}\niso:{{iso}}\niso8601:{{iso8601}}\nutc:{{utc}}\nrfc7231:{{rfc7231}}\nlocal:{{local}}\ntime:{{time}}\nYYYY:{{YYYY}}\nMM:{{MM}}\nDD:{{DD}}\nhh:{{hh}}\nmm:{{mm}}\nss:{{ss}}\nms:{{ms}}\nfull_year:{{full_year}}\nmonth:{{month}}\ndate:{{date}}\nday:{{day}}\nhours:{{hours}}\nminutes:{{minutes}}\nseconds:{{seconds}}\nmilliseconds:{{milliseconds}}\ntimezone_offset:{{timezone_offset}}\nutc_full_year:{{utc_full_year}}\nutc_month:{{utc_month}}\nutc_date:{{utc_date}}\nutc_day:{{utc_day}}\nutc_hours:{{utc_hours}}\nutc_minutes:{{utc_minutes}}\nutc_seconds:{{utc_seconds}}\nutc_milliseconds:{{utc_milliseconds}}\nlocal_weekday:{{local_weekday}}\nlocal_literal:{{local_literal}}\nlocal_day:{{local_day}}\nlocal_month:{{local_month}}\nlocal_year:{{local_year}}\nlocal_hour:{{local_hour}}\nlocal_minute:{{local_minute}}\nlocal_second:{{local_second}}\nlocal_timeZoneName:{{local_timeZoneName}}'
+        ]),
+      ),
+    ),
+  );
+})
+
+Deno.test("format template with transform", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--template',
+          '{{rfc7231:json}}'
+        ]),
+      ),
+    ),
+  );
+})
+
+Deno.test("format template with transform", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--template',
+          '{{rfc7231:sub:0:3}}'
+        ]),
+      ),
+    ),
+  );
+})
+
+Deno.test("format template with transform", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--template',
+          '{{month:padStart:4:0}}'
+        ]),
+      ),
+    ),
+  );
+})
+
+Deno.test("format template with transform", async (t) => {
+  await assertSnapshot(
+    t,
+    new TextDecoder().decode(
+      await joinUint8ArrayGenerator(
+        handler([
+          "-z",
+          "-d",
+          "2023-08-08T03:38:58.570Z",
+          "-l",
+          "es-cl",
+          '-tz',
+          "America/Santiago",
+          '--template',
+          '{{month:padEnd:4:0}}'
+        ]),
+      ),
+    ),
+  );
+})
diff --git a/ndate.ts b/ndate.ts
index cd0a44f..bfd08cf 100755
--- a/ndate.ts
+++ b/ndate.ts
@@ -2,10 +2,6 @@
 
 import { handler } from "./handler.ts";
 
-const run = async () => {
-    for await (const buff of handler(Deno.args)) {
-        Deno.stdout.write(buff)
-    }
+for await (const buff of handler(Deno.args)) {
+    Deno.stdout.write(buff)
 }
-
-await run();