base128-ascii 3.2.0 → 4.0.1

package/main.d.ts

@@ -1,10 +1,5 @@
-export declare class Base128Bytes {
-    constructor();
-    constructor(length: number);
-    constructor(array: ArrayLike<number>);
-    constructor<TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number);
-    constructor(buffer: ArrayBuffer, byteOffset?: number, length?: number);
-    constructor(array: ArrayLike<number> | ArrayBuffer);
+export declare class EncodeResult {
+    constructor(bytes: Uint8Array);
 
     /**
      * Returns a base128 string.
@@ -16,42 +11,19 @@ export declare class Base128Bytes {
      */
     toJSTemplateLiterals(): string;
 
-    /**
-     * Returns a base128 Uint8Array.
-     */
-    uint8Array(): Uint8Array<ArrayBufferLike>;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
     get buffer(): ArrayBufferLike;
 
-    /**
-     * The length in bytes of the array.
-     */
-    get byteLength(): number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    get byteOffset(): number;
-
-    /**
-     * The length of the array.
-     */
-    get length(): number;
-
-    [index: number]: number;
+    readonly bytes: Uint8Array;
 }
 
-export declare function encode(input: Uint8Array | string): Base128Bytes;
+export declare function encode(input: Uint8Array | string | ArrayLike<number> | ArrayBuffer | Pick<ArrayBufferView, "buffer">): EncodeResult;
 
 export declare function decode(input: string): Uint8Array;
 
-declare const base128 = {
-    Base128Bytes,
-    encode,
-    decode,
+declare const base128: {
+    EncodeResult: typeof EncodeResult,
+    encode: typeof encode,
+    decode: typeof decode,
 };
 
 export default base128;

package/main.js

@@ -1,44 +1,60 @@
 //@ts-nocheck
 
-export const Base128Bytes = (() => {
-    class Base128Bytes {
-        constructor() {
-            return Reflect.construct(Uint8Array, arguments, new.target)
-        }
-        toString() {
-            return new TextDecoder().decode(this)
-        }
-        toJSTemplateLiterals() {
-            return `\`${this.toString().replace(
-                /[\r\\`]|\$\{|<\/script/g,
-                (match) => (
-                    match == '\r'
-                        ? '\\r'
-                        : match == '</script'
-                            ? '<\\/script'
-                            : '\\' + match
-                )
-            )}\``
-        }
-        uint8Array() {
-            return new Uint8Array(this.buffer)
+export class EncodeResult {
+    /**
+     * @param {Uint8Array} bytes 
+     */
+    constructor(bytes) {
+        if (!(bytes instanceof Uint8Array)) {
+            throw TypeError(`EncodeResult: Must input Uint8Array`)
         }
+        Object.defineProperty(this, "bytes", { value: bytes, enumerable: true })
     }
-    const p = Object.getPrototypeOf(Uint8Array.prototype)
-    for (const key of ["buffer", "byteLength", "byteOffset", "length"]) {
-        Object.defineProperty(Base128Bytes.prototype, key, Object.getOwnPropertyDescriptor(p, key))
+    toString() {
+        return new TextDecoder().decode(this.bytes)
     }
-    return Base128Bytes
-})()
+    toJSTemplateLiterals() {
+        return `\`${this.toString().replace(
+            /[\r\\`]|\$\{|<\/script/g,
+            (match) => (
+                match == '\r'
+                    ? '\\r'
+                    : match == '</script'
+                        ? '<\\/script'
+                        : '\\' + match
+            )
+        )}\``
+    }
+    get buffer() {
+        return this.bytes.buffer
+    }
+}
 
 /**
- * @param {Uint8Array | string} input
+ * @param {Uint8Array | string | ArrayLike<number> | ArrayBuffer | Pick<ArrayBufferView, "buffer">} input
  */
 export function encode(input) {
-    if (typeof input == 'string')
+    if (input == null) {
+        throw TypeError(`encode: Cannot input null or undefined`)
+    }
+    if (input instanceof Uint8Array) {
+        // Uint8Array | Buffer
+    } else if (typeof input == 'string') {
+        // string
         input = new TextEncoder().encode(input)
+    } else if (input instanceof ArrayBuffer) {
+        // ArrayBuffer
+        input = new Uint8Array(input)
+    } else if (input.buffer instanceof ArrayBuffer) {
+        // TypedArray | DataView | Pick<ArrayBufferView, "buffer">
+        input = new Uint8Array(input.buffer)
+    }
+    // else ArrayLike<number>
     var il = input.length
-        , out = new Base128Bytes(Math.ceil(il / 7 * 8))
+    if (typeof il != 'number') {
+        throw TypeError(`encode: typeof input.length must be number`)
+    }
+    var out = new Uint8Array(Math.ceil(il / 7 * 8))
         , ii = 0
         , oi = 0
     while (ii < il) {
@@ -55,13 +71,16 @@ export function encode(input) {
         /* 6 */ out[oi++] = (input[ii++] << 1 | input[ii] >> 7) & 127
         /* 7 */ out[oi++] = input[ii++] & 127
     }
-    return out
+    return new EncodeResult(out)
 }
 
 /**
  * @param {string} input
  */
 export function decode(input) {
+    if (typeof input != 'string') {
+        throw TypeError(`decode: Must input string`)
+    }
     var il = input.length
         , out = new Uint8Array(il / 8 * 7)
         , ii = 0
@@ -89,7 +108,7 @@ export function decode(input) {
 }
 
 export default {
-    Base128Bytes,
+    EncodeResult,
     encode,
     decode
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "base128-ascii",
-  "version": "3.2.0",
+  "version": "4.0.1",
   "author": "bddjr",
   "license": "Unlicense",
   "type": "module",