com.sweaxizone.w3c.extension 1.0.2 → 1.0.4

package/README.md

@@ -60,7 +60,7 @@ ExampleEnum.valueOf(x) // val: number
 ExampleEnum.plus("variantA", 1) // 1
 ```
 
-## Other globals
+## Other additions
 
 - `assert`
 - `AssertionError`
@@ -73,6 +73,9 @@ ExampleEnum.plus("variantA", 1) // 1
 - `isXMLName(argument)` (like E4X's `isXMLName()`)
 - `Namespace` (like E4X's `Namespace`)
 - `QName` (like E4X's `QName`)
+- `Iterator.prototype.length()`
+- `Chars`
+- `String.prototype.chars()`
 
 ## License
 

package/dist/Chars.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Chars.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Chars
+globalThis.Chars = class Chars extends Iterator {
+    _str;
+    _length;
+    _offset;
+    constructor(str, offset = -1) {
+        super();
+        this._str = str;
+        this._length = str.length;
+        this._offset = offset == -1 ? 0 : offset;
+    }
+    get hasRemaining() {
+        return this._offset < this._length;
+    }
+    get reachedEnd() {
+        return this._offset >= this._length;
+    }
+    next() {
+        const ch = this._str.codePointAt(this._offset);
+        if (ch === undefined) {
+            return { done: true, value: 0 };
+        }
+        if (ch >= 0x10000) {
+            this._offset++;
+        }
+        this._offset++;
+        return { done: false, value: ch };
+    }
+    skipOneInPlace() {
+        this.next();
+    }
+    skipInPlace(count) {
+        for (let i = 0; i < count; i++) {
+            if (this.next().done) {
+                break;
+            }
+        }
+    }
+    get index() {
+        return this._offset;
+    }
+    get nextOrZero() {
+        const r = this.next();
+        return r.done ? 0 : r.value;
+    }
+    peek() {
+        return this._str.codePointAt(this._offset) ?? null;
+    }
+    peekOrZero() {
+        return this._str.codePointAt(this._offset) ?? 0;
+    }
+    at(index) {
+        let offset = this._offset;
+        for (let i = 0; i < index; i++) {
+            const ch = this._str.codePointAt(offset);
+            if (ch === undefined) {
+                break;
+            }
+            if (ch >= 0x10000) {
+                offset++;
+            }
+            offset++;
+        }
+        return this._str.codePointAt(offset) ?? null;
+    }
+    atOrZero(index) {
+        return this.at(index) ?? 0;
+    }
+    seq(numChars) {
+        const r = [];
+        let offset = this._offset;
+        for (let i = 0; i < numChars; i++) {
+            const ch = this._str.codePointAt(offset);
+            if (ch === undefined) {
+                break;
+            }
+            if (ch >= 0x10000) {
+                offset++;
+            }
+            offset++;
+            r.push(String.fromCodePoint(ch));
+        }
+        return r.join("");
+    }
+};
+// String.prototype.chars()
+String.prototype.chars = function () {
+    return new Chars(this);
+};

package/dist/E4X.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/E4X.js

@@ -1,4 +1,5 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 // isXMLName
 function isXMLName(argument) {
     argument = String(argument);

package/dist/Enum.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Enum.js

@@ -1,8 +1,9 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 globalThis.Enum = function Enum(variants, methods = null) {
     const fn = (key) => key;
     fn.valueOf = (key) => variants[key];
-    fn.variants = () => Array.from(Object.keys(variants));
+    fn.variants = () => Object.keys(variants);
     fn.from = (arg) => {
         if (typeof arg == "string") {
             const v = typeof variants[arg];

package/dist/SAByteArray.js

@@ -1,4 +1,9 @@
-import assert from "assert";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
 //
 const validEndianSet = ["bigEndian", "littleEndian"];
 //
@@ -11,7 +16,7 @@ globalThis.SAByteArray = class SAByteArray {
     m_endian = "bigEndian";
     constructor(initialCapacityArg = undefined) {
         let initialCapacity = initialCapacityArg === undefined ? SAByteArray.INITIAL_CAPACITY : initialCapacityArg;
-        assert(initialCapacity >= 2, 'SAByteArray initial capacity must be >= 2.');
+        (0, assert_1.default)(initialCapacity >= 2, 'SAByteArray initial capacity must be >= 2.');
         this.m_dataview = new DataView(new ArrayBuffer(initialCapacity));
         this.m_u8array = new Uint8Array(this.m_dataview.buffer);
     }
@@ -63,7 +68,7 @@ globalThis.SAByteArray = class SAByteArray {
         return this.m_endian;
     }
     set endian(val) {
-        assert(validEndianSet.indexOf(val) != -1);
+        (0, assert_1.default)(validEndianSet.indexOf(val) != -1);
         this.m_endian = val;
     }
     get length() {
@@ -122,7 +127,7 @@ globalThis.SAByteArray = class SAByteArray {
         }
     }
     readUnsignedByte() {
-        assert(this.m_position < this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position < this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getUint8(this.m_position);
         this.m_position += 1;
         return k;
@@ -133,7 +138,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 1;
     }
     readByte() {
-        assert(this.m_position < this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position < this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getInt8(this.m_position);
         this.m_position += 1;
         return k;
@@ -144,7 +149,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 1;
     }
     readShort() {
-        assert(this.m_position + 2 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 2 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getInt16(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 2;
         return k;
@@ -155,7 +160,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 2;
     }
     readUnsignedShort() {
-        assert(this.m_position + 2 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 2 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getUint16(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 2;
         return k;
@@ -166,7 +171,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 2;
     }
     readInt() {
-        assert(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getInt32(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 4;
         return k;
@@ -177,7 +182,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 4;
     }
     readUnsignedInt() {
-        assert(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getUint32(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 4;
         return k;
@@ -188,7 +193,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 4;
     }
     readLong() {
-        assert(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getBigInt64(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 8;
         return k;
@@ -199,7 +204,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 8;
     }
     readUnsignedLong() {
-        assert(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getBigUint64(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 8;
         return k;
@@ -210,7 +215,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 8;
     }
     readFloat() {
-        assert(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getFloat32(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 4;
         return k;
@@ -221,7 +226,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 4;
     }
     readDouble() {
-        assert(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_dataview.getFloat64(this.m_position, this.m_endian == "littleEndian");
         this.m_position += 8;
         return k;
@@ -232,7 +237,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += 8;
     }
     readUTF(length) {
-        assert(this.m_position + length <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + length <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_u8array.subarray(this.m_position, this.m_position + length);
         this.m_position += length;
         return new TextDecoder().decode(k);
@@ -244,7 +249,7 @@ globalThis.SAByteArray = class SAByteArray {
         this.m_position += u8arr.length;
     }
     readBytes(length) {
-        assert(this.m_position + length <= this.m_length, 'Insufficient data available to read.');
+        (0, assert_1.default)(this.m_position + length <= this.m_length, 'Insufficient data available to read.');
         let k = this.m_u8array.subarray(this.m_position, this.m_position + length);
         this.m_position += length;
         return SAByteArray.from(k);

package/dist/SAEventTarget.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/SAEventTarget.js

@@ -1,4 +1,5 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 // EventRecord
 globalThis.EventRecord = Symbol("http://sweaxizone.com/javascript/EventRecord");
 // SAEventTarget

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import "./Enum";
 import "./E4X";
 import "./SAEventTarget";
 import "./SAByteArray";
+import "./Chars";
 import impAssert from "assert";
 declare global {
     const assert: typeof import("assert");
@@ -202,3 +203,80 @@ declare global {
         valueOf(): QName;
     }
 }
+declare global {
+    interface IteratorObject<T, TReturn, TNext> {
+        /**
+         * Consumes the iterator and returns the number of
+         * iterated entries.
+         */
+        length(): number;
+    }
+}
+declare global {
+    /**
+     * `Chars` may be used for iterating characters (as Unicode code points)
+     * from left-to-right in a string with miscellaneous operation methods.
+     */
+    class Chars extends Iterator<number> {
+        /**
+         * Constructs a `Chars` iterator over the specified string,
+         * at the specified UTF-16 `offset`.
+         */
+        constructor(str: string, offset?: number);
+        /**
+         * Indicates if there are remaining code points to read.
+         */
+        get hasRemaining(): boolean;
+        /**
+         * Indicates if the reader has reached the end of the string.
+         */
+        get reachedEnd(): boolean;
+        next(): IteratorResult<number>;
+        /**
+         * Returns the next code point. If there are no code points
+         * available, returns U+00.
+         */
+        get nextOrZero(): number;
+        /**
+         * Skips a code point. This is equivalent to
+         * calling `next()`.
+         */
+        skipOneInPlace(): void;
+        /**
+         * Skips the given number of code points.
+         */
+        skipInPlace(count: number): void;
+        /**
+         * Returns the current UTF-16 offset in the string.
+         */
+        get index(): number;
+        /**
+         * Peeks the next code point.
+         */
+        peek(): null | number;
+        /**
+         * Peeks the next code point. If there are no code points
+         * available, returns U+00.
+         */
+        peekOrZero(): number;
+        /**
+         * Peeks the next code point at the given
+         * zero based code point index.
+         */
+        at(index: number): null | number;
+        /**
+         * Peeks the next code point at the given zero based code point index.
+         * If there are no code points available, returns U+00.
+         */
+        atOrZero(index: number): number;
+        /**
+         * Peeks a number of code points until the string's end.
+         */
+        seq(numChars: number): string;
+    }
+}
+declare global {
+    interface String {
+        chars(): Chars;
+    }
+}

package/dist/index.js

@@ -1,11 +1,17 @@
-import "./Enum";
-import "./E4X";
-import "./SAEventTarget";
-import "./SAByteArray";
-import impAssert from "assert";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./Enum");
+require("./E4X");
+require("./SAEventTarget");
+require("./SAByteArray");
+require("./Chars");
+const assert_1 = __importDefault(require("assert"));
 // assert
-globalThis.assert = impAssert;
-globalThis.AssertionError = impAssert.AssertionError;
+globalThis.assert = assert_1.default;
+globalThis.AssertionError = assert_1.default.AssertionError;
 // trace(), etrace()
 globalThis.trace = console.log;
 globalThis.etrace = console.error;
@@ -32,3 +38,11 @@ BigInt.max = (...rest) => {
     }
     return r;
 };
+// Iterator.length()
+Iterator.prototype.length = function () {
+    let n = 0;
+    for (const _ of this) {
+        n++;
+    }
+    return n;
+};

package/dist/src/Chars.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Chars.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Chars
+globalThis.Chars = class Chars extends Iterator {
+    _str;
+    _length;
+    _offset;
+    constructor(str, offset = -1) {
+        super();
+        this._str = str;
+        this._length = str.length;
+        this._offset = offset == -1 ? 0 : offset;
+    }
+    get hasRemaining() {
+        return this._offset < this._length;
+    }
+    get reachedEnd() {
+        return this._offset >= this._length;
+    }
+    next() {
+        const ch = this._str.codePointAt(this._offset);
+        if (ch === undefined) {
+            return { done: true, value: 0 };
+        }
+        if (ch >= 0x10000) {
+            this._offset++;
+        }
+        this._offset++;
+        return { done: false, value: ch };
+    }
+    skipOneInPlace() {
+        this.next();
+    }
+    skipInPlace(count) {
+        for (let i = 0; i < count; i++) {
+            if (this.next().done) {
+                break;
+            }
+        }
+    }
+    get index() {
+        return this._offset;
+    }
+    get nextOrZero() {
+        const r = this.next();
+        return r.done ? 0 : r.value;
+    }
+    peek() {
+        return this._str.codePointAt(this._offset) ?? null;
+    }
+    peekOrZero() {
+        return this._str.codePointAt(this._offset) ?? 0;
+    }
+    at(index) {
+        let offset = this._offset;
+        for (let i = 0; i < index; i++) {
+            const ch = this._str.codePointAt(offset);
+            if (ch === undefined) {
+                break;
+            }
+            if (ch >= 0x10000) {
+                offset++;
+            }
+            offset++;
+        }
+        return this._str.codePointAt(offset) ?? null;
+    }
+    atOrZero(index) {
+        return this.at(index) ?? 0;
+    }
+    seq(numChars) {
+        const r = [];
+        let offset = this._offset;
+        for (let i = 0; i < numChars; i++) {
+            const ch = this._str.codePointAt(offset);
+            if (ch === undefined) {
+                break;
+            }
+            if (ch >= 0x10000) {
+                offset++;
+            }
+            offset++;
+            r.push(String.fromCodePoint(ch));
+        }
+        return r.join("");
+    }
+};
+// String.prototype.chars()
+String.prototype.chars = function () {
+    return new Chars(this);
+};

package/dist/src/E4X.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/E4X.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// isXMLName
+function isXMLName(argument) {
+    argument = String(argument);
+    return /[a-z_][a-z_0-9.\-]*/i.test(argument);
+}
+globalThis.isXMLName = isXMLName;
+// Namespace
+globalThis.Namespace = class Namespace {
+    _prefix = "";
+    _uri = "";
+    // Namespace(uri:*)
+    // Namespace(prefix:*, uri:*)
+    constructor(arg1 = undefined, arg2 = undefined) {
+        if (arg2 === undefined || arg2 === null) {
+            if (arg1 instanceof Namespace) {
+                this._uri = arg1.uri;
+            }
+            else if (arg1 instanceof QName) {
+                this._uri = arg1.uri ?? "";
+            }
+            else {
+                this._uri = String(arg1);
+            }
+        }
+        else {
+            // arg1 = prefixValue
+            if (arg1 === undefined && !isXMLName(arg1)) {
+                this._prefix = "undefined";
+            }
+            else {
+                this._prefix = String(arg1);
+            }
+            // arg2 = uriValue
+            if (arg2 instanceof QName) {
+                this._uri = arg2.uri ?? "";
+            }
+            else {
+                this._uri = String(arg2);
+            }
+        }
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    set prefix(val) {
+        this._prefix = String(val);
+    }
+    get uri() {
+        return this._uri;
+    }
+    set uri(val) {
+        this._uri = String(val);
+    }
+    toString() {
+        return this._uri;
+    }
+    valueOf() {
+        return this._uri;
+    }
+};
+// QName
+globalThis.QName = class QName {
+    _uri = null;
+    _localName = "";
+    // QName(qname:*)
+    // QName(uri:*, localName:*)
+    constructor(arg1 = undefined, arg2 = undefined) {
+        // QName(qname:*)
+        if (arg2 === undefined || arg2 === null) {
+            if (arg1 === undefined || arg1 === null) {
+                this._localName = "";
+            }
+            else if (arg1 instanceof QName) {
+                this._uri = arg1.uri;
+                this._localName = arg1.localName;
+            }
+            else {
+                this._localName = String(arg1);
+            }
+            // QName(uri:*, localName:*)
+        }
+        else {
+            if (arg1 !== undefined && arg1 !== null) {
+                if (arg1 instanceof Namespace) {
+                    this._uri = arg1.uri;
+                }
+                else {
+                    this._uri = String(arg1);
+                }
+            }
+            if (arg2 instanceof QName) {
+                this._localName = arg2.localName;
+            }
+            else {
+                this._localName = String(arg2);
+            }
+        }
+    }
+    get localName() {
+        return this._localName;
+    }
+    // null = wildcard (*)
+    get uri() {
+        return this._uri;
+    }
+    toString() {
+        const { uri, localName } = this;
+        return uri === "" ? localName : uri === null ? "*::" + localName : uri + "::" + localName;
+    }
+    valueOf() {
+        return this;
+    }
+};

package/dist/src/Enum.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Enum.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+globalThis.Enum = function Enum(variants, methods = null) {
+    const fn = (key) => key;
+    fn.valueOf = (key) => variants[key];
+    fn.variants = () => Object.keys(variants);
+    fn.from = (arg) => {
+        if (typeof arg == "string") {
+            const v = typeof variants[arg];
+            return v == "number" || v == "bigint" ? arg : null;
+        }
+        if (typeof arg == "number" || typeof arg == "bigint") {
+            return Object.entries(variants).find(([k, v]) => v === arg)?.[0] ?? null;
+        }
+        return null;
+    };
+    if (methods) {
+        Object.assign(fn, methods);
+    }
+    return fn;
+};

package/dist/src/SAByteArray.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/SAByteArray.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+//
+const validEndianSet = ["bigEndian", "littleEndian"];
+//
+globalThis.SAByteArray = class SAByteArray {
+    static INITIAL_CAPACITY = 8;
+    m_dataview;
+    m_u8array;
+    m_position = 0;
+    m_length = 0;
+    m_endian = "bigEndian";
+    constructor(initialCapacityArg = undefined) {
+        let initialCapacity = initialCapacityArg === undefined ? SAByteArray.INITIAL_CAPACITY : initialCapacityArg;
+        (0, assert_1.default)(initialCapacity >= 2, 'SAByteArray initial capacity must be >= 2.');
+        this.m_dataview = new DataView(new ArrayBuffer(initialCapacity));
+        this.m_u8array = new Uint8Array(this.m_dataview.buffer);
+    }
+    static withCapacity(bytes) {
+        return new SAByteArray(bytes);
+    }
+    static zeroes(length) {
+        const r = new SAByteArray();
+        r.m_dataview = new DataView(new ArrayBuffer(Math.max(2, length >> 0)));
+        r.m_u8array = new Uint8Array(r.m_dataview.buffer);
+        r.m_length = length;
+        return r;
+    }
+    static from(arg) {
+        const r = new SAByteArray();
+        if (arg instanceof SAByteArray) {
+            r.m_dataview = new DataView(arg.m_dataview.buffer.slice(0));
+            r.m_u8array = new Uint8Array(r.m_dataview.buffer);
+            r.m_length = arg.m_length;
+            return r;
+        }
+        r.m_dataview = new DataView(arg instanceof Uint8Array ? arg.buffer : arg);
+        r.m_u8array = new Uint8Array(r.m_dataview.buffer);
+        r.m_length = r.m_dataview.byteLength;
+        return r;
+    }
+    clone() {
+        return SAByteArray.from(this);
+    }
+    toArrayBuffer() {
+        return this.m_dataview.buffer;
+    }
+    toBuffer() {
+        return Buffer.from(this.m_dataview.buffer.slice(0));
+    }
+    equals(other) {
+        const l = this.m_length;
+        if (l != other.m_length) {
+            return false;
+        }
+        for (let i = 0; i < l; i++) {
+            if (this.m_u8array[i] != other.m_u8array[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    get endian() {
+        return this.m_endian;
+    }
+    set endian(val) {
+        (0, assert_1.default)(validEndianSet.indexOf(val) != -1);
+        this.m_endian = val;
+    }
+    get length() {
+        return this.m_length >>> 0;
+    }
+    set length(val) {
+        this.m_length = Math.min(Math.max(0, val >>> 0), this.m_length);
+    }
+    get position() {
+        return this.m_position >>> 0;
+    }
+    set position(val) {
+        this.m_position = Math.min(Math.max(val >>> 0, 0), this.m_length);
+    }
+    get bytesAvailable() {
+        return this.length - this.position;
+    }
+    get hasRemaining() {
+        return this.position < this.length;
+    }
+    get(position) {
+        return position < this.m_length ? this.m_u8array[position] : 0;
+    }
+    set(position, val) {
+        if (position >= this.m_length) {
+            throw new RangeError("Index is out of bounds (index=" + position + ", length=" + this.m_length + ")");
+        }
+        this.m_u8array[position] = val >>> 0;
+    }
+    paygrow(length) {
+        const ipl = this.m_position + length;
+        // double buffer capacity as needed
+        while (ipl > this.m_dataview.byteLength) {
+            const arraybuf = new ArrayBuffer(this.m_dataview.byteLength * 2);
+            this.m_dataview = new DataView(arraybuf);
+            const k = this.m_u8array;
+            this.m_u8array = new Uint8Array(arraybuf);
+            this.m_u8array.set(k.subarray(0, this.m_length));
+        }
+        const newBytes = -(this.m_length - ipl);
+        this.m_length += Math.max(0, newBytes);
+    }
+    *[Symbol.iterator]() {
+        for (let i = 0; i < this.m_length; i++) {
+            yield this.m_u8array[i];
+        }
+    }
+    *keys() {
+        for (let i = 0; i < this.m_length; i++) {
+            yield i;
+        }
+    }
+    *values() {
+        for (let i = 0; i < this.m_length; i++) {
+            yield this.m_u8array[i];
+        }
+    }
+    readUnsignedByte() {
+        (0, assert_1.default)(this.m_position < this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getUint8(this.m_position);
+        this.m_position += 1;
+        return k;
+    }
+    writeUnsignedByte(value) {
+        this.paygrow(1);
+        this.m_dataview.setUint8(this.m_position, value);
+        this.m_position += 1;
+    }
+    readByte() {
+        (0, assert_1.default)(this.m_position < this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getInt8(this.m_position);
+        this.m_position += 1;
+        return k;
+    }
+    writeByte(value) {
+        this.paygrow(1);
+        this.m_dataview.setInt8(this.m_position, value);
+        this.m_position += 1;
+    }
+    readShort() {
+        (0, assert_1.default)(this.m_position + 2 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getInt16(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 2;
+        return k;
+    }
+    writeShort(value) {
+        this.paygrow(2);
+        this.m_dataview.setInt16(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 2;
+    }
+    readUnsignedShort() {
+        (0, assert_1.default)(this.m_position + 2 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getUint16(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 2;
+        return k;
+    }
+    writeUnsignedShort(value) {
+        this.paygrow(2);
+        this.m_dataview.setUint16(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 2;
+    }
+    readInt() {
+        (0, assert_1.default)(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getInt32(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 4;
+        return k;
+    }
+    writeInt(value) {
+        this.paygrow(4);
+        this.m_dataview.setInt32(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 4;
+    }
+    readUnsignedInt() {
+        (0, assert_1.default)(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getUint32(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 4;
+        return k;
+    }
+    writeUnsignedInt(value) {
+        this.paygrow(4);
+        this.m_dataview.setUint32(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 4;
+    }
+    readLong() {
+        (0, assert_1.default)(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getBigInt64(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 8;
+        return k;
+    }
+    writeLong(value) {
+        this.paygrow(8);
+        this.m_dataview.setBigInt64(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 8;
+    }
+    readUnsignedLong() {
+        (0, assert_1.default)(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getBigUint64(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 8;
+        return k;
+    }
+    writeUnsignedLong(value) {
+        this.paygrow(8);
+        this.m_dataview.setBigUint64(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 8;
+    }
+    readFloat() {
+        (0, assert_1.default)(this.m_position + 4 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getFloat32(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 4;
+        return k;
+    }
+    writeFloat(value) {
+        this.paygrow(4);
+        this.m_dataview.setFloat32(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 4;
+    }
+    readDouble() {
+        (0, assert_1.default)(this.m_position + 8 <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_dataview.getFloat64(this.m_position, this.m_endian == "littleEndian");
+        this.m_position += 8;
+        return k;
+    }
+    writeDouble(value) {
+        this.paygrow(8);
+        this.m_dataview.setFloat64(this.m_position, value, this.m_endian == "littleEndian");
+        this.m_position += 8;
+    }
+    readUTF(length) {
+        (0, assert_1.default)(this.m_position + length <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_u8array.subarray(this.m_position, this.m_position + length);
+        this.m_position += length;
+        return new TextDecoder().decode(k);
+    }
+    writeUTF(value) {
+        var u8arr = new TextEncoder().encode(value);
+        this.paygrow(u8arr.length);
+        this.m_u8array.set(u8arr, this.m_position);
+        this.m_position += u8arr.length;
+    }
+    readBytes(length) {
+        (0, assert_1.default)(this.m_position + length <= this.m_length, 'Insufficient data available to read.');
+        let k = this.m_u8array.subarray(this.m_position, this.m_position + length);
+        this.m_position += length;
+        return SAByteArray.from(k);
+    }
+    writeBytes(value) {
+        const u8arr = value.m_u8array;
+        this.paygrow(u8arr.length);
+        this.m_u8array.set(u8arr, this.m_position);
+        ;
+        this.m_position += u8arr.length;
+    }
+    clear() {
+        this.m_position = 0;
+        this.m_length = 0;
+        const arraybuf = new ArrayBuffer(SAByteArray.INITIAL_CAPACITY);
+        this.m_dataview = new DataView(arraybuf);
+        this.m_u8array = new Uint8Array(arraybuf);
+    }
+};

package/dist/src/SAEventTarget.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/SAEventTarget.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// EventRecord
+globalThis.EventRecord = Symbol("http://sweaxizone.com/javascript/EventRecord");
+// SAEventTarget
+globalThis.SAEventTarget = class SAEventTarget {
+    //
+    m_eventTarget = new globalThis.EventTarget();
+    //
+    on(type, listener, options = undefined) {
+        const new_options = typeof options == "object"
+            ? { capture: options.capture }
+            : options;
+        this.m_eventTarget.addEventListener(type, listener, new_options);
+    }
+    //
+    off(type, listener, options = undefined) {
+        const new_options = typeof options == "object"
+            ? { capture: options.capture }
+            : options;
+        this.m_eventTarget.removeEventListener(type, listener, new_options);
+    }
+    //
+    emit(arg1, arg2, arg3) {
+        let event = null;
+        if (arg1 instanceof Event) {
+            event = arg1;
+        }
+        else {
+            event = typeof arg3 !== "undefined" ?
+                new arg2(arg1, arg3) :
+                new arg2(arg1);
+        }
+        return this.m_eventTarget.dispatchEvent(event);
+    }
+};

package/dist/src/index.d.ts

@@ -0,0 +1,282 @@
+import "./Enum";
+import "./E4X";
+import "./SAEventTarget";
+import "./SAByteArray";
+import "./Chars";
+import impAssert from "assert";
+declare global {
+    const assert: typeof import("assert");
+    class AssertionError extends impAssert.AssertionError {
+    }
+    type AssertPredicate = impAssert.AssertPredicate;
+}
+declare global {
+    /**
+     * Used to declare known compile-time events
+     * for a class that extends `EventTarget` or
+     * implements `IEventTarget`.
+     */
+    const EventRecord: unique symbol;
+    /**
+     * `SAEventTarget` stands for Short-Augmented Event Target.
+     */
+    class SAEventTarget implements ISAEventTarget {
+        [EventRecord]: {};
+        on<K extends keyof this[typeof EventRecord]>(type: K, listener: (e: this[typeof EventRecord][K] extends Event ? this[typeof EventRecord][K] : never) => void | undefined, options?: boolean | SAOnEventOptions): void;
+        on(type: string, listener: (e: Event) => void | undefined, options?: boolean | SAOnEventOptions): void;
+        off<K extends keyof this[typeof EventRecord]>(type: K, listener: (e: this[typeof EventRecord][K] extends Event ? this[typeof EventRecord][K] : never) => void | undefined, options?: boolean | SAOffEventOptions): void;
+        off(type: string, listener: (e: Event) => void | undefined, options?: boolean | SAOffEventOptions): void;
+        emit<K extends string & keyof this[typeof EventRecord], C extends (new (type: K) => EventResult), EventResult extends this[typeof EventRecord][K]>(type: K, constructor: C): boolean;
+        emit<K extends string & keyof this[typeof EventRecord], C extends (new (type: K, options: O) => EventResult), O, EventResult extends this[typeof EventRecord][K]>(type: K, constructor: C, options: O): boolean;
+        emit(event: Event): boolean;
+    }
+    interface ISAEventTarget {
+        [EventRecord]: {};
+        on<K extends keyof this[typeof EventRecord]>(type: K, listener: (e: this[typeof EventRecord][K] extends Event ? this[typeof EventRecord][K] : never) => void | undefined, options?: boolean | SAOnEventOptions): void;
+        on(type: string, listener: (e: Event) => void | undefined, options?: boolean | SAOnEventOptions): void;
+        off<K extends keyof this[typeof EventRecord]>(type: K, listener: (e: this[typeof EventRecord][K] extends Event ? this[typeof EventRecord][K] : never) => void | undefined, options?: boolean | SAOffEventOptions): void;
+        off(type: string, listener: (e: Event) => void | undefined, options?: boolean | SAOffEventOptions): void;
+        emit<K extends string & keyof this[typeof EventRecord], C extends (new (type: K) => EventResult), EventResult extends this[typeof EventRecord][K]>(type: K, constructor: C): boolean;
+        emit<K extends string & keyof this[typeof EventRecord], C extends (new (type: K, options: O) => EventResult), O, EventResult extends this[typeof EventRecord][K]>(type: K, constructor: C, options: O): boolean;
+        emit(event: Event): boolean;
+    }
+    type SAOnEventOptions = {
+        capture?: boolean;
+    };
+    type SAOffEventOptions = {
+        capture?: boolean;
+    };
+}
+declare global {
+    /**
+     * Simple enumerations with number-to-string mapping and vice-versa,
+     * as well as the ability to add documentation comments to
+     * variants.
+     */
+    function Enum<K extends string, V extends number | bigint, UserMethods>(variants: Record<K, V>, methods?: UserMethods): EnumType<K, V, UserMethods>;
+    type EnumType<K, V, UserMethods> = {
+        (key: K): K;
+        from(arg: string | number | bigint): null | K;
+        valueOf(key: K): V;
+        variants(): K[];
+    } & (UserMethods extends object ? UserMethods : {});
+}
+declare global {
+    const trace: typeof console.log;
+    const etrace: typeof console.error;
+}
+declare global {
+    interface Math {
+        /**
+         * Clamps value to specified range (inclusive on both ends).
+         */
+        clamp(val: number, from: number, to: number): number;
+        /**
+         * Clamps value to specified range (inclusive on both ends).
+         */
+        clamp(val: bigint, from: bigint, to: bigint): bigint;
+    }
+}
+declare global {
+    interface BigIntConstructor {
+        min(...rest: bigint[]): bigint;
+        max(...rest: bigint[]): bigint;
+    }
+}
+declare global {
+    type Endian = "littleEndian" | "bigEndian";
+    class SAByteArray implements ISADataInput, ISADataOutput {
+        constructor(initialCapacity?: number);
+        static withCapacity(bytes: number): SAByteArray;
+        static zeroes(length: number): SAByteArray;
+        static from(argument: SAByteArray | Uint8Array | ArrayBuffer | SharedArrayBuffer): SAByteArray;
+        clone(): SAByteArray;
+        toArrayBuffer(): ArrayBuffer;
+        /**
+         * *Applies to the Node.js runtime.*
+         */
+        toBuffer(): Buffer;
+        equals(other: SAByteArray): boolean;
+        get endian(): Endian;
+        set endian(val: Endian);
+        get length(): number;
+        set length(val: number);
+        get position(): number;
+        set position(val: number);
+        get bytesAvailable(): number;
+        get hasRemaining(): boolean;
+        get(position: number): number;
+        set(position: number, val: number): void;
+        [Symbol.iterator](): Iterator<number>;
+        keys(): Iterator<number>;
+        values(): Iterator<number>;
+        readUnsignedByte(): number;
+        writeUnsignedByte(value: number): void;
+        readByte(): number;
+        writeByte(value: number): void;
+        readShort(): number;
+        writeShort(value: number): void;
+        readUnsignedShort(): number;
+        writeUnsignedShort(value: number): void;
+        readInt(): number;
+        writeInt(value: number): void;
+        readUnsignedInt(): number;
+        writeUnsignedInt(value: number): void;
+        readLong(): bigint;
+        writeLong(value: bigint): void;
+        readUnsignedLong(): bigint;
+        writeUnsignedLong(value: bigint): void;
+        readFloat(): number;
+        writeFloat(value: number): void;
+        readDouble(): number;
+        writeDouble(value: number): void;
+        readUTF(length: number): string;
+        writeUTF(value: string): void;
+        readBytes(length: number): SAByteArray;
+        writeBytes(value: SAByteArray): void;
+        clear(): void;
+    }
+    interface ISADataInput {
+        get endian(): Endian;
+        set endian(val: Endian);
+        get bytesAvailable(): number;
+        get hasRemaining(): boolean;
+        readUnsignedByte(): number;
+        readByte(): number;
+        readShort(): number;
+        readUnsignedShort(): number;
+        readInt(): number;
+        readUnsignedInt(): number;
+        readLong(): bigint;
+        readUnsignedLong(): bigint;
+        readFloat(): number;
+        readDouble(): number;
+        readUTF(length: number): string;
+        readBytes(length: number): SAByteArray;
+    }
+    interface ISADataOutput {
+        get endian(): Endian;
+        set endian(val: Endian);
+        writeUnsignedByte(value: number): void;
+        writeByte(value: number): void;
+        writeShort(value: number): void;
+        writeUnsignedShort(value: number): void;
+        writeInt(value: number): void;
+        writeUnsignedInt(value: number): void;
+        writeLong(value: bigint): void;
+        writeUnsignedLong(value: bigint): void;
+        writeFloat(value: number): void;
+        writeDouble(value: number): void;
+        writeUTF(value: string): void;
+        writeBytes(value: SAByteArray): void;
+    }
+}
+declare global {
+    function isXMLName(argument: string): boolean;
+    /**
+     * Represents a XML namespace.
+     */
+    class Namespace {
+        constructor(uri: string | Namespace | QName);
+        constructor(prefix: string, uri: string | QName);
+        get prefix(): string;
+        set prefix(val: string);
+        get uri(): string;
+        set uri(val: string);
+        toString(): string;
+        valueOf(): string;
+    }
+    /**
+     * Represents a XML qualified name.
+     *
+     * The `uri` component may be `null`, in which
+     * case it means *wildcard* (\*), used to match
+     * any URI.
+     */
+    class QName {
+        constructor(localName: string);
+        constructor(qname: QName);
+        constructor(uri: null | Namespace | string, localName: QName | string);
+        get localName(): string;
+        get uri(): null | string;
+        toString(): string;
+        valueOf(): QName;
+    }
+}
+declare global {
+    interface IteratorObject<T, TReturn, TNext> {
+        /**
+         * Consumes the iterator and returns the number of
+         * iterated entries.
+         */
+        length(): number;
+    }
+}
+declare global {
+    /**
+     * `Chars` may be used for iterating characters (as Unicode code points)
+     * from left-to-right in a string with miscellaneous operation methods.
+     */
+    class Chars extends Iterator<number> {
+        /**
+         * Constructs a `Chars` iterator over the specified string,
+         * at the specified UTF-16 `offset`.
+         */
+        constructor(str: string, offset?: number);
+        /**
+         * Indicates if there are remaining code points to read.
+         */
+        get hasRemaining(): boolean;
+        /**
+         * Indicates if the reader has reached the end of the string.
+         */
+        get reachedEnd(): boolean;
+        next(): IteratorResult<number>;
+        /**
+         * Returns the next code point. If there are no code points
+         * available, returns U+00.
+         */
+        get nextOrZero(): number;
+        /**
+         * Skips a code point. This is equivalent to
+         * calling `next()`.
+         */
+        skipOneInPlace(): void;
+        /**
+         * Skips the given number of code points.
+         */
+        skipInPlace(count: number): void;
+        /**
+         * Returns the current UTF-16 offset in the string.
+         */
+        get index(): number;
+        /**
+         * Peeks the next code point.
+         */
+        peek(): null | number;
+        /**
+         * Peeks the next code point. If there are no code points
+         * available, returns U+00.
+         */
+        peekOrZero(): number;
+        /**
+         * Peeks the next code point at the given
+         * zero based code point index.
+         */
+        at(index: number): null | number;
+        /**
+         * Peeks the next code point at the given zero based code point index.
+         * If there are no code points available, returns U+00.
+         */
+        atOrZero(index: number): number;
+        /**
+         * Peeks a number of code points until the string's end.
+         */
+        seq(numChars: number): string;
+    }
+}
+declare global {
+    interface String {
+        chars(): Chars;
+    }
+}

package/dist/src/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./Enum");
+require("./E4X");
+require("./SAEventTarget");
+require("./SAByteArray");
+require("./Chars");
+const assert_1 = __importDefault(require("assert"));
+// assert
+globalThis.assert = assert_1.default;
+globalThis.AssertionError = assert_1.default.AssertionError;
+// trace(), etrace()
+globalThis.trace = console.log;
+globalThis.etrace = console.error;
+// Math.clamp()
+Math.clamp = (val, from, to) => {
+    return val < from ? from : val > to ? to : val;
+};
+// BigInt.min(), BigInt.max()
+BigInt.min = (...rest) => {
+    let r = rest.pop() ?? 0n;
+    for (const val of rest) {
+        if (val < r) {
+            r = val;
+        }
+    }
+    return r;
+};
+BigInt.max = (...rest) => {
+    let r = rest.pop() ?? 0n;
+    for (const val of rest) {
+        if (val > r) {
+            r = val;
+        }
+    }
+    return r;
+};
+// Iterator.length()
+Iterator.prototype.length = function () {
+    let n = 0;
+    for (const _ of this) {
+        n++;
+    }
+    return n;
+};

package/dist/test/src/Chars.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/src/Chars.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let reader = "foo".chars();

package/dist/test/src/index.d.ts

@@ -0,0 +1,2 @@
+import "com.sweaxizone.w3c.extension";
+import "./Chars";

package/dist/test/src/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("com.sweaxizone.w3c.extension");
+require("./Chars");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.sweaxizone.w3c.extension",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Global object additions for W3C-compliant runtimes.",
   "scripts": {
     "build": "tsc",