base128-ascii 3.0.0 → 3.1.1

package/README.md

@@ -14,9 +14,11 @@ npm i base128-ascii
 import base128 from "base128-ascii"
 import fs from "fs"
 
-const encodedTemplate = base128.encode(fs.readFileSync("example.gz")).toJSTemplateLiterals()
+const input = fs.readFileSync("example.gz")
 
-const decoded = base128.decode(eval(encodedTemplate))
+const encodedTemplate = base128.encode(input).toJSTemplateLiterals()
+
+const decodedBytes = base128.decode(eval(encodedTemplate))
 ```
 
 ---

package/main.d.ts

@@ -1,18 +1,52 @@
-export declare class Base128Bytes extends Uint8Array {
+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);
+
     /**
      * Returns a base128 string.
      */
     toString(): string;
+
     /**
      * Returns a base128 [Template literals](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Template_literals).
      */
     toJSTemplateLiterals(): string;
+
+    /**
+     * 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;
 }
+
 export declare function encode(input: Uint8Array | string): Base128Bytes;
+
 export declare function decode(input: string): Uint8Array;
-declare const base128: {
-    Base128Bytes: typeof Base128Bytes;
-    encode: typeof encode;
-    decode: typeof decode;
+
+declare const base128 = {
+    Base128Bytes,
+    encode,
+    decode,
 };
+
 export default base128;

package/main.js

@@ -1,22 +1,32 @@
 //@ts-nocheck
 
-export class Base128Bytes extends Uint8Array {
-    toString() {
-        return new TextDecoder().decode(this)
+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
+                )
+            )}\``
+        }
     }
-    toJSTemplateLiterals() {
-        return `\`${this.toString().replace(
-            /[\r\\`]|\$\{|<\/script/g,
-            (match) => (
-                match == '\r'
-                    ? '\\r'
-                    : match == '</script'
-                        ? '<\\/script'
-                        : '\\' + match
-            )
-        )}\``
+    const p = Object.getPrototypeOf(Uint8Array.prototype)
+    for (const key of ["buffer", "byteLength", "byteOffset", "length"]) {
+        Object.defineProperty(Base128Bytes.prototype, key, Object.getOwnPropertyDescriptor(p, key))
     }
-}
+    return Base128Bytes
+})()
 
 /**
  * @param {Uint8Array | string} input

package/package.json

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