com.sweaxizone.w3c.extension 1.0.3 → 1.0.5

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;
+    }
+    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/Enum.js

@@ -3,7 +3,7 @@ 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/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.
+         */
+        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

@@ -7,6 +7,7 @@ require("./Enum");
 require("./E4X");
 require("./SAEventTarget");
 require("./SAByteArray");
+require("./Chars");
 const assert_1 = __importDefault(require("assert"));
 // assert
 globalThis.assert = assert_1.default;
@@ -37,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/package.json

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