@jlbyte/tester 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jlongyam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,60 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Tester
+
+Tiny cross-runtime test runner,
+Standard JS only.
+
+## Support
+
+- Node
+- Deno
+- Bun
+- browsers
+
+## Usage
+
+### CLI
+
+```js
+import { assert, it, run } from '@jlbyte/tester';
+
+it('Sample Test', ()=> {
+  assert.equal(1,1)
+});
+it('Shoulf fail', ()=> {
+  assert.ok(null, 'aah')
+})
+
+run()
+```
+
+### Browser
+
+```html
+<script type="importmap">
+  {
+    "imports": {
+      "@jlbyte/ansi": "https://cdn.jsdelivr.net/npm/@jlbyte/ansi@1.2.1/+esm",
+      "@jlbyte/env": "https://cdn.jsdelivr.net/npm/@jlbyte/env@1.1.0/+esm",
+      "@jlbyte/tester": "https://cdn.jsdelivr.net/npm/@jlbyte/tester@1.0.0/+esm"
+    }
+  }
+</script>
+<link href="https://cdn.jsdelivr.net/npm/@jlbyte/env@1.1.0/dist/tester.css" rel="stylesheet">
+<script type="module">
+  import { assert, it, run } from '@jlbyte/tester';
+
+  it('Sample Test', ()=> {
+    assert.equal(1,1)
+  });
+  it('Shoulf fail', ()=> {
+    assert.ok(null, 'aah')
+  })
+
+  await run()
+</script>
+</body>
+```
+
+## License
+
+License [MIT](LICENSE)

package/dist/tester.cjs

@@ -0,0 +1,200 @@
+'use strict';
+
+var ansi = require('@jlbyte/ansi');
+var env = require('@jlbyte/env');
+
+function deepEqual(a, b, seen = new WeakMap()) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== 'object' || typeof b !== 'object') return false;
+  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+  if (seen.get(a) === b) return true;
+  seen.set(a, b);
+  
+  if (a instanceof Date) return a.getTime() === b.getTime();
+  if (a instanceof RegExp) return String(a) === String(b);
+  if (a instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEqual(v, b.get(k), seen)) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const v of a) if (!b.has(v)) return false;
+    return true;
+  }
+  
+  const aKeys = Reflect.ownKeys(a);
+  const bKeys = Reflect.ownKeys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key], seen)) return false;
+  }
+  
+  return true;
+}
+
+class AssertionError extends Error {
+  constructor(message, actual, expected) {
+    super(message);
+    this.name = 'AssertionError';
+    this.actual = actual;
+    this.expected = expected;
+  }
+}
+
+function show(value) {
+  const seen = new WeakSet();
+  try {
+    return JSON.stringify(value, (key, v) => {
+      if (v === undefined) return '[undefined]';
+      if (typeof v === 'number' && !Number.isFinite(v)) return `[${v}]`;
+      if (typeof v === 'bigint') return `[${v}n]`;
+      if (typeof v === 'function') return `[Function ${v.name || 'anonymous'}]`;
+      if (typeof v === 'symbol') return v.toString();
+      if (v instanceof Map) return { '[Map]': [...v] };
+      if (v instanceof Set) return { '[Set]': [...v] };
+      if (v instanceof RegExp) return String(v);
+      if (v && typeof v === 'object') {
+        if (seen.has(v)) return '[Circular]';
+        seen.add(v);
+      }
+      return v;
+    });
+  } catch {
+    return String(value);
+  }
+}
+
+function assert(value, message) {
+  if (!value) throw new AssertionError(message || `Expected ${show(value)} to be truthy`, value, true);
+}
+
+assert.ok = assert;
+
+assert.equal = (actual, expected, message) => {
+  if (!Object.is(actual, expected)) {
+    throw new AssertionError(message || `Expected ${show(actual)} to be ${show(expected)}`, actual, expected);
+  }
+};
+
+assert.deepEqual = (actual, expected, message) => {
+  if (!deepEqual(actual, expected)) {
+    throw new AssertionError(message || `Expected ${show(actual)} to deeply equal ${show(expected)}`, actual, expected);
+  }
+};
+
+assert.throws = (fn, message) => {
+  try { fn(); } catch { return; }
+  throw new AssertionError(message || 'Expected function to throw', undefined, undefined);
+};
+
+const { fg, bg, fgBright } = ansi.color; 
+const { cli, browser } = env;
+
+let el_tester;
+let el_info_head;
+
+if(browser) {
+  el_tester = document.createElement('div');
+  el_tester.className = 'tester-runner';
+  if(!('test_runner_container' in window)) {
+    let el_test_runner_container = document.createElement('div');
+    el_test_runner_container.id = 'test_runner_container';
+    el_test_runner_container.appendChild(el_tester);
+    document.body.appendChild(el_test_runner_container);
+  }
+  else {
+    test_runner_container.appendChild(el_tester);
+  }
+}
+let Test = {
+  report: [],
+  result: { passed: 0, failed: 0 },
+  add: function (name, fn) {
+    this.report.push({ name: name, fn: fn });
+  },
+  run: async function () {
+    this.result = { passed: 0, failed: 0 };
+    if(browser) {
+      var el_group = document.createElement('div');
+      el_group.className = 'tester-runner__group';
+      el_tester.appendChild(el_group);
+      var el_test_head = document.createElement('div');
+      el_test_head.className = 'tester-runner__group--head';
+      el_test_head.innerHTML += ansi.html(ansi.style.underline('Test'));
+      el_group.appendChild(el_test_head);
+    }
+    if(cli) {
+      console.group(`\n${ansi.style.underline('Test')}\n`);
+    }
+    for (var i = 0; i < this.report.length; i++) {
+      var test = this.report[i];
+      if(browser) {
+        var el_test = document.createElement('div');
+        el_test.className = 'tester-runner__group--test';
+        el_group.appendChild(el_test);
+      }
+      try {
+        const result = test.fn();
+        if (result && typeof result.then === 'function') {
+          await result;
+        }
+        this.result.passed++;
+        if(cli) {
+          console.log(`${fg.green(ansi.icon.ok)} ${fgBright.blue(test.name)}`);
+        }
+        if(browser) {
+          el_test.innerHTML += ansi.html(`${fg.green(ansi.icon.ok)} ${fgBright.blue(test.name)}`);
+        }
+      } catch (e) {
+        this.result.failed++;
+        if(cli) {
+          console.log(`${fgBright.red(ansi.icon.fail)} ${fgBright.red(test.name)}`);
+          console.groupCollapsed();
+            console.log(fgBright.black(e.message));
+          console.groupEnd();
+        }
+        if(browser) {
+          el_test.innerHTML += ansi.html(`${fgBright.red(ansi.icon.fail)} ${fgBright.red(test.name)}`);
+          var el_test_sub = document.createElement('div');
+          el_test_sub.className = 'tester-runner__group--test__sub';
+          el_test_sub.innerHTML += ansi.html(fgBright.black(e.message));
+          el_test.appendChild(el_test_sub);
+        }
+      }
+    }
+    if(cli) {
+      console.groupEnd();
+      console.group(`\n${ansi.style.underline('Result')}\n`);
+        console.info(`${bg.green(fgBright.white(` ${this.result.passed} `))} ${fg.green('passed')}, ${bg.red(fgBright.white(` ${this.result.failed} `))} ${fgBright.red('failed')}`);
+      console.groupEnd();
+    }
+    if(browser) {
+      var el_info = document.createElement('div');
+      el_info.className = 'tester-runner__info';
+      el_tester.appendChild(el_info);
+      el_info_head = document.createElement('div');
+      el_info_head.className = 'tester-runner__info--head';
+      el_info_head.innerHTML = ansi.html(ansi.style.underline('Result'));
+      el_info.appendChild(el_info_head);
+      var el_info_result = document.createElement('div');
+      el_info_result.className = 'tester-runner__info--result';
+      el_info_result.innerHTML = ansi.html(`${bg.green(fgBright.white(` ${this.result.passed} `))} ${fg.green('passed')}, ${bg.red(fgBright.white(` ${this.result.failed} `))} ${fgBright.red('failed')}`);
+      el_info.appendChild(el_info_result);
+    }
+  }
+};
+function it(name, fn) {
+  Test.add(name, fn);
+}
+function run() {
+  return Test.run();
+}
+
+exports.assert = assert;
+exports.it = it;
+exports.run = run;

package/dist/tester.js

@@ -0,0 +1,202 @@
+var tester = (function (exports, ansi, env) {
+  'use strict';
+
+  function deepEqual(a, b, seen = new WeakMap()) {
+    if (Object.is(a, b)) return true;
+    if (a === null || b === null) return false;
+    if (typeof a !== 'object' || typeof b !== 'object') return false;
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+    if (seen.get(a) === b) return true;
+    seen.set(a, b);
+    
+    if (a instanceof Date) return a.getTime() === b.getTime();
+    if (a instanceof RegExp) return String(a) === String(b);
+    if (a instanceof Map) {
+      if (a.size !== b.size) return false;
+      for (const [k, v] of a) {
+        if (!b.has(k) || !deepEqual(v, b.get(k), seen)) return false;
+      }
+      return true;
+    }
+    if (a instanceof Set) {
+      if (a.size !== b.size) return false;
+      for (const v of a) if (!b.has(v)) return false;
+      return true;
+    }
+    
+    const aKeys = Reflect.ownKeys(a);
+    const bKeys = Reflect.ownKeys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+      if (!deepEqual(a[key], b[key], seen)) return false;
+    }
+    
+    return true;
+  }
+
+  class AssertionError extends Error {
+    constructor(message, actual, expected) {
+      super(message);
+      this.name = 'AssertionError';
+      this.actual = actual;
+      this.expected = expected;
+    }
+  }
+
+  function show(value) {
+    const seen = new WeakSet();
+    try {
+      return JSON.stringify(value, (key, v) => {
+        if (v === undefined) return '[undefined]';
+        if (typeof v === 'number' && !Number.isFinite(v)) return `[${v}]`;
+        if (typeof v === 'bigint') return `[${v}n]`;
+        if (typeof v === 'function') return `[Function ${v.name || 'anonymous'}]`;
+        if (typeof v === 'symbol') return v.toString();
+        if (v instanceof Map) return { '[Map]': [...v] };
+        if (v instanceof Set) return { '[Set]': [...v] };
+        if (v instanceof RegExp) return String(v);
+        if (v && typeof v === 'object') {
+          if (seen.has(v)) return '[Circular]';
+          seen.add(v);
+        }
+        return v;
+      });
+    } catch {
+      return String(value);
+    }
+  }
+
+  function assert(value, message) {
+    if (!value) throw new AssertionError(message || `Expected ${show(value)} to be truthy`, value, true);
+  }
+
+  assert.ok = assert;
+
+  assert.equal = (actual, expected, message) => {
+    if (!Object.is(actual, expected)) {
+      throw new AssertionError(message || `Expected ${show(actual)} to be ${show(expected)}`, actual, expected);
+    }
+  };
+
+  assert.deepEqual = (actual, expected, message) => {
+    if (!deepEqual(actual, expected)) {
+      throw new AssertionError(message || `Expected ${show(actual)} to deeply equal ${show(expected)}`, actual, expected);
+    }
+  };
+
+  assert.throws = (fn, message) => {
+    try { fn(); } catch { return; }
+    throw new AssertionError(message || 'Expected function to throw', undefined, undefined);
+  };
+
+  const { fg, bg, fgBright } = ansi.color; 
+  const { cli, browser } = env;
+
+  let el_tester;
+  let el_info_head;
+
+  if(browser) {
+    el_tester = document.createElement('div');
+    el_tester.className = 'tester-runner';
+    if(!('test_runner_container' in window)) {
+      let el_test_runner_container = document.createElement('div');
+      el_test_runner_container.id = 'test_runner_container';
+      el_test_runner_container.appendChild(el_tester);
+      document.body.appendChild(el_test_runner_container);
+    }
+    else {
+      test_runner_container.appendChild(el_tester);
+    }
+  }
+  let Test = {
+    report: [],
+    result: { passed: 0, failed: 0 },
+    add: function (name, fn) {
+      this.report.push({ name: name, fn: fn });
+    },
+    run: async function () {
+      this.result = { passed: 0, failed: 0 };
+      if(browser) {
+        var el_group = document.createElement('div');
+        el_group.className = 'tester-runner__group';
+        el_tester.appendChild(el_group);
+        var el_test_head = document.createElement('div');
+        el_test_head.className = 'tester-runner__group--head';
+        el_test_head.innerHTML += ansi.html(ansi.style.underline('Test'));
+        el_group.appendChild(el_test_head);
+      }
+      if(cli) {
+        console.group(`\n${ansi.style.underline('Test')}\n`);
+      }
+      for (var i = 0; i < this.report.length; i++) {
+        var test = this.report[i];
+        if(browser) {
+          var el_test = document.createElement('div');
+          el_test.className = 'tester-runner__group--test';
+          el_group.appendChild(el_test);
+        }
+        try {
+          const result = test.fn();
+          if (result && typeof result.then === 'function') {
+            await result;
+          }
+          this.result.passed++;
+          if(cli) {
+            console.log(`${fg.green(ansi.icon.ok)} ${fgBright.blue(test.name)}`);
+          }
+          if(browser) {
+            el_test.innerHTML += ansi.html(`${fg.green(ansi.icon.ok)} ${fgBright.blue(test.name)}`);
+          }
+        } catch (e) {
+          this.result.failed++;
+          if(cli) {
+            console.log(`${fgBright.red(ansi.icon.fail)} ${fgBright.red(test.name)}`);
+            console.groupCollapsed();
+              console.log(fgBright.black(e.message));
+            console.groupEnd();
+          }
+          if(browser) {
+            el_test.innerHTML += ansi.html(`${fgBright.red(ansi.icon.fail)} ${fgBright.red(test.name)}`);
+            var el_test_sub = document.createElement('div');
+            el_test_sub.className = 'tester-runner__group--test__sub';
+            el_test_sub.innerHTML += ansi.html(fgBright.black(e.message));
+            el_test.appendChild(el_test_sub);
+          }
+        }
+      }
+      if(cli) {
+        console.groupEnd();
+        console.group(`\n${ansi.style.underline('Result')}\n`);
+          console.info(`${bg.green(fgBright.white(` ${this.result.passed} `))} ${fg.green('passed')}, ${bg.red(fgBright.white(` ${this.result.failed} `))} ${fgBright.red('failed')}`);
+        console.groupEnd();
+      }
+      if(browser) {
+        var el_info = document.createElement('div');
+        el_info.className = 'tester-runner__info';
+        el_tester.appendChild(el_info);
+        el_info_head = document.createElement('div');
+        el_info_head.className = 'tester-runner__info--head';
+        el_info_head.innerHTML = ansi.html(ansi.style.underline('Result'));
+        el_info.appendChild(el_info_head);
+        var el_info_result = document.createElement('div');
+        el_info_result.className = 'tester-runner__info--result';
+        el_info_result.innerHTML = ansi.html(`${bg.green(fgBright.white(` ${this.result.passed} `))} ${fg.green('passed')}, ${bg.red(fgBright.white(` ${this.result.failed} `))} ${fgBright.red('failed')}`);
+        el_info.appendChild(el_info_result);
+      }
+    }
+  };
+  function it(name, fn) {
+    Test.add(name, fn);
+  }
+  function run() {
+    return Test.run();
+  }
+
+  exports.assert = assert;
+  exports.it = it;
+  exports.run = run;
+
+  return exports;
+
+})({}, ansi, env);

package/dist/tester.mjs

@@ -0,0 +1,196 @@
+import { color, html, style, icon } from '@jlbyte/ansi';
+import env from '@jlbyte/env';
+
+function deepEqual(a, b, seen = new WeakMap()) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== 'object' || typeof b !== 'object') return false;
+  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+  if (seen.get(a) === b) return true;
+  seen.set(a, b);
+  
+  if (a instanceof Date) return a.getTime() === b.getTime();
+  if (a instanceof RegExp) return String(a) === String(b);
+  if (a instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEqual(v, b.get(k), seen)) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const v of a) if (!b.has(v)) return false;
+    return true;
+  }
+  
+  const aKeys = Reflect.ownKeys(a);
+  const bKeys = Reflect.ownKeys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key], seen)) return false;
+  }
+  
+  return true;
+}
+
+class AssertionError extends Error {
+  constructor(message, actual, expected) {
+    super(message);
+    this.name = 'AssertionError';
+    this.actual = actual;
+    this.expected = expected;
+  }
+}
+
+function show(value) {
+  const seen = new WeakSet();
+  try {
+    return JSON.stringify(value, (key, v) => {
+      if (v === undefined) return '[undefined]';
+      if (typeof v === 'number' && !Number.isFinite(v)) return `[${v}]`;
+      if (typeof v === 'bigint') return `[${v}n]`;
+      if (typeof v === 'function') return `[Function ${v.name || 'anonymous'}]`;
+      if (typeof v === 'symbol') return v.toString();
+      if (v instanceof Map) return { '[Map]': [...v] };
+      if (v instanceof Set) return { '[Set]': [...v] };
+      if (v instanceof RegExp) return String(v);
+      if (v && typeof v === 'object') {
+        if (seen.has(v)) return '[Circular]';
+        seen.add(v);
+      }
+      return v;
+    });
+  } catch {
+    return String(value);
+  }
+}
+
+function assert(value, message) {
+  if (!value) throw new AssertionError(message || `Expected ${show(value)} to be truthy`, value, true);
+}
+
+assert.ok = assert;
+
+assert.equal = (actual, expected, message) => {
+  if (!Object.is(actual, expected)) {
+    throw new AssertionError(message || `Expected ${show(actual)} to be ${show(expected)}`, actual, expected);
+  }
+};
+
+assert.deepEqual = (actual, expected, message) => {
+  if (!deepEqual(actual, expected)) {
+    throw new AssertionError(message || `Expected ${show(actual)} to deeply equal ${show(expected)}`, actual, expected);
+  }
+};
+
+assert.throws = (fn, message) => {
+  try { fn(); } catch { return; }
+  throw new AssertionError(message || 'Expected function to throw', undefined, undefined);
+};
+
+const { fg, bg, fgBright } = color; 
+const { cli, browser } = env;
+
+let el_tester;
+let el_info_head;
+
+if(browser) {
+  el_tester = document.createElement('div');
+  el_tester.className = 'tester-runner';
+  if(!('test_runner_container' in window)) {
+    let el_test_runner_container = document.createElement('div');
+    el_test_runner_container.id = 'test_runner_container';
+    el_test_runner_container.appendChild(el_tester);
+    document.body.appendChild(el_test_runner_container);
+  }
+  else {
+    test_runner_container.appendChild(el_tester);
+  }
+}
+let Test = {
+  report: [],
+  result: { passed: 0, failed: 0 },
+  add: function (name, fn) {
+    this.report.push({ name: name, fn: fn });
+  },
+  run: async function () {
+    this.result = { passed: 0, failed: 0 };
+    if(browser) {
+      var el_group = document.createElement('div');
+      el_group.className = 'tester-runner__group';
+      el_tester.appendChild(el_group);
+      var el_test_head = document.createElement('div');
+      el_test_head.className = 'tester-runner__group--head';
+      el_test_head.innerHTML += html(style.underline('Test'));
+      el_group.appendChild(el_test_head);
+    }
+    if(cli) {
+      console.group(`\n${style.underline('Test')}\n`);
+    }
+    for (var i = 0; i < this.report.length; i++) {
+      var test = this.report[i];
+      if(browser) {
+        var el_test = document.createElement('div');
+        el_test.className = 'tester-runner__group--test';
+        el_group.appendChild(el_test);
+      }
+      try {
+        const result = test.fn();
+        if (result && typeof result.then === 'function') {
+          await result;
+        }
+        this.result.passed++;
+        if(cli) {
+          console.log(`${fg.green(icon.ok)} ${fgBright.blue(test.name)}`);
+        }
+        if(browser) {
+          el_test.innerHTML += html(`${fg.green(icon.ok)} ${fgBright.blue(test.name)}`);
+        }
+      } catch (e) {
+        this.result.failed++;
+        if(cli) {
+          console.log(`${fgBright.red(icon.fail)} ${fgBright.red(test.name)}`);
+          console.groupCollapsed();
+            console.log(fgBright.black(e.message));
+          console.groupEnd();
+        }
+        if(browser) {
+          el_test.innerHTML += html(`${fgBright.red(icon.fail)} ${fgBright.red(test.name)}`);
+          var el_test_sub = document.createElement('div');
+          el_test_sub.className = 'tester-runner__group--test__sub';
+          el_test_sub.innerHTML += html(fgBright.black(e.message));
+          el_test.appendChild(el_test_sub);
+        }
+      }
+    }
+    if(cli) {
+      console.groupEnd();
+      console.group(`\n${style.underline('Result')}\n`);
+        console.info(`${bg.green(fgBright.white(` ${this.result.passed} `))} ${fg.green('passed')}, ${bg.red(fgBright.white(` ${this.result.failed} `))} ${fgBright.red('failed')}`);
+      console.groupEnd();
+    }
+    if(browser) {
+      var el_info = document.createElement('div');
+      el_info.className = 'tester-runner__info';
+      el_tester.appendChild(el_info);
+      el_info_head = document.createElement('div');
+      el_info_head.className = 'tester-runner__info--head';
+      el_info_head.innerHTML = html(style.underline('Result'));
+      el_info.appendChild(el_info_head);
+      var el_info_result = document.createElement('div');
+      el_info_result.className = 'tester-runner__info--result';
+      el_info_result.innerHTML = html(`${bg.green(fgBright.white(` ${this.result.passed} `))} ${fg.green('passed')}, ${bg.red(fgBright.white(` ${this.result.failed} `))} ${fgBright.red('failed')}`);
+      el_info.appendChild(el_info_result);
+    }
+  }
+};
+function it(name, fn) {
+  Test.add(name, fn);
+}
+function run() {
+  return Test.run();
+}
+
+export { assert, it, run };

package/dist/types/tester.d.mts

@@ -0,0 +1,11 @@
+declare function assert(value: any, message: any): void;
+declare namespace assert {
+    export { assert as ok };
+    export var equal: (actual: any, expected: any, message: any) => void;
+    export var _a: (actual: any, expected: any, message: any) => void;
+    export { _a as deepEqual };
+    export var throws: (fn: any, message: any) => void;
+}
+declare function it(name: any, fn: any): void;
+declare function run(): Promise<void>;
+export { assert, it, run };

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@jlbyte/tester",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "JS Tester library",
+  "keywords": [
+    "test",
+    "tester",
+    "assert",
+    "test-runner"
+  ],
+  "homepage": "https://github.com/jlongyam/core",
+  "repository": {
+    "url": "https://github.com/jlongyam/core",
+    "directory": "packages/tester"
+  },
+  "license": "MIT",
+  "author": "jlongyam",
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.2",
+    "rollup": "^4.66.0",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@jlbyte/ansi": "^1.2.1",
+    "@jlbyte/env": "^1.1.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/tester.mjs",
+      "require": "./dist/env.cjs",
+      "browser": "./dist/env.js",
+      "types": "./dist/types/env.d.mts"
+    }
+  },
+  "module": "dist/env.mjs",
+  "browser": "dist/env.js",
+  "types": "dist/types/env.d.mts",
+  "files": [
+    "README.md",
+    "LICENSE",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "index.mjs",
+  "scripts": {
+    "usage": "node usage/test.mjs",
+    "build:rollup": "rollup --input=./src/tester.mjs --dir ./dist --format es --entryFileNames \"[name].mjs\" -p node-resolve -e bowser,@jlbyte/ansi,@jlbyte/env && rollup --input=./src/tester.mjs --dir ./dist --format cjs --entryFileNames \"[name].cjs\" -p node-resolve -e bowser,@jlbyte/ansi,@jlbyte/env && rollup --input=./src/tester.mjs --dir ./dist --name tester --format iife --entryFileNames \"[name].js\" -p node-resolve -e bowser,@jlbyte/ansi,@jlbyte/env -g bowser:bowser,ansi:ansi,env:env",
+    "build:types": "tsc --allowJs --declaration --emitDeclarationOnly --rootDir ./dist --outDir ./dist/types ./dist/tester.mjs",
+    "build": "npm run build:rollup && npm run build:types"
+  }
+}