anthelpers 0.0.2 → 0.1.0

package/.idea/workspace.xml

@@ -5,9 +5,19 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="cbb82d94-0dbd-445b-8adb-15f10cc25fd5" name="Changes" comment="git add ,">
+      <change afterPath="$PROJECT_DIR$/.gitignore" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Random.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Random.ts" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/deepEquals.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/deepEquals.ts" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/parseBigInt.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/parseBigInt.ts" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/promise.d.ts" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/tests.js" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/index.js" beforeDir="false" afterPath="$PROJECT_DIR$/index.js" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/index.ts" beforeDir="false" afterPath="$PROJECT_DIR$/index.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/package.json" beforeDir="false" afterPath="$PROJECT_DIR$/package.json" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tsconfig.json" beforeDir="false" afterPath="$PROJECT_DIR$/tsconfig.json" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -21,6 +31,7 @@
     <option name="RECENT_TEMPLATES">
       <list>
         <option value="JavaScript File" />
+        <option value="TypeScript File" />
       </list>
     </option>
   </component>
@@ -64,6 +75,11 @@
     &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
   }
 }</component>
+  <component name="RecentsManager">
+    <key name="MoveFile.RECENT_KEYS">
+      <recent name="D:\var\www\BOTs\antHelpers" />
+    </key>
+  </component>
   <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
   <component name="TaskManager">
     <task active="true" id="Default" summary="Default task">
@@ -75,7 +91,18 @@
       <workItem from="1750690125892" duration="677000" />
       <workItem from="1750701696645" duration="1183000" />
       <workItem from="1751299376418" duration="401000" />
-      <workItem from="1751299850777" duration="55000" />
+      <workItem from="1751299850777" duration="165000" />
+      <workItem from="1751300373838" duration="17000" />
+      <workItem from="1757840101515" duration="6954000" />
+      <workItem from="1757922653752" duration="3977000" />
+      <workItem from="1758026845729" duration="60000" />
+      <workItem from="1758153479792" duration="47000" />
+      <workItem from="1758195396963" duration="724000" />
+      <workItem from="1758196639774" duration="11000" />
+      <workItem from="1759948417753" duration="22000" />
+      <workItem from="1760055007271" duration="99000" />
+      <workItem from="1760360991867" duration="6060000" />
+      <workItem from="1760367500301" duration="5155000" />
     </task>
     <task id="LOCAL-00001" summary="git add ,">
       <option name="closed" value="true" />
@@ -93,6 +120,15 @@
     <option name="exactExcludedFiles">
       <list>
         <option value="$PROJECT_DIR$/index.js" />
+        <option value="$PROJECT_DIR$/WebWorkers/PromisedWorker.js" />
+        <option value="$PROJECT_DIR$/WebWorkers/PromisedWorkerInside.js" />
+        <option value="$PROJECT_DIR$/WebWorkers/FetchedWorker.js" />
+        <option value="$PROJECT_DIR$/WebWorkers/CustomError.js" />
+        <option value="$PROJECT_DIR$/WebWorkers/FetchedWorkerWithin.js" />
+        <option value="$PROJECT_DIR$/parseBigInt.js" />
+        <option value="$PROJECT_DIR$/deepEquals.js" />
+        <option value="$PROJECT_DIR$/WebWorkers/FWClass.js" />
+        <option value="$PROJECT_DIR$/Random.js" />
       </list>
     </option>
   </component>

package/Random.js

@@ -0,0 +1,76 @@
+// javascript.js
+import { EXMAScript } from "./index.js";
+export class Random {
+    #seed;
+    constructor(seed = 0n) {
+        this.#seed = BigInt(seed);
+    }
+    next(min = 0n, max = 1000n) {
+        // Linear congruential generator
+        this.#seed = (this.#seed * 6364136223846793005n + 1n) & ((1n << 64n) - 1n);
+        min = BigInt(min);
+        max = BigInt(max);
+        return min + (this.#seed % (max - min));
+    }
+    [Symbol.toStringTag] = "PRandom";
+    static [Symbol.toStringTag] = "PRandom constructor";
+    fillArray(array, min = 0n, max = 100000n) {
+        const length = EXMAScript.toIntegerOrInfinity(array?.length);
+        if (length === 0)
+            return array;
+        for (let i = 0; i < length; i++) {
+            const skip = (array[i] = this.next(min, max)) % 17n;
+            for (let ii = 0; ii < skip; ii++)
+                this.next(min, max);
+        }
+        return array;
+    }
+}
+export class WeightedRandomRarity extends Random {
+    #rarities;
+    constructor(rarities, seed = undefined) {
+        super(BigInt(seed ?? Date.now()));
+        const entries = Object.entries(Object.assign({}, rarities));
+        (this.#rarities = entries.map(([key, value]) => [key,
+            Math.trunc(value)])).forEach(([key, value]) => {
+            if (value < 0)
+                throw new RangeError(`${key}: is negative`);
+        });
+    }
+    // @ts-expect-error
+    next() {
+        const entries = this.#rarities;
+        const total = this.cumulative();
+        const rand = super.next(0n, BigInt(total));
+        let cumulative = 0;
+        for (const [key, w] of entries) {
+            cumulative += w;
+            if (rand < cumulative)
+                return key;
+        }
+        return entries[0][0];
+    }
+    cumulative() {
+        const entries = this.#rarities;
+        return entries.reduce((sum, [, value]) => sum + value, 0);
+    }
+    getOdds() {
+        const total = this.cumulative();
+        const entries = this.#rarities, result = {
+            [Symbol.toStringTag]: "Rarities", total,
+            asPercents: { [Symbol.toStringTag]: "Rarities asPercents" },
+            asFloats: { [Symbol.toStringTag]: "Rarities asFloats" },
+            internal: { [Symbol.toStringTag]: "Rarities asFloats" },
+        };
+        for (const entry of entries) {
+            result.internal[entry[0]] = entry[1];
+            result.asFloats[entry[0]] = entry[1] / total;
+            const asPercent = ((entry[1] / total) * 100).toFixed(2) + '%';
+            result.asPercents[entry[0]] = asPercent.replace(/\.00%$/, '%');
+        }
+        Object.freeze(result.internal);
+        Object.freeze(result.asFloats);
+        Object.freeze(result.asPercents);
+        return Object.freeze(result);
+    }
+}

package/Random.ts

@@ -0,0 +1,86 @@
+// Random.ts
+import {EXMAScript} from "./index.js";
+
+export class Random {
+    #seed;
+
+    constructor(seed = 0n) {
+        this.#seed = BigInt(seed);
+    }
+
+    next(min: bigint = 0n, max: bigint = 1000n): bigint {
+        // Linear congruential generator
+        this.#seed = (this.#seed * 6364136223846793005n + 1n) & ((1n << 64n) - 1n);
+        min = BigInt(min);
+        max = BigInt(max);
+        return min + (this.#seed % (max - min));
+    }
+
+    [Symbol.toStringTag] = "PRandom";
+    static [Symbol.toStringTag] = "PRandom constructor";
+
+    fillArray(array: unknown[], min: bigint = 0n, max: bigint = 100000n) {
+        const length = EXMAScript.toIntegerOrInfinity(array?.length);
+        if (length === 0) return array;
+        for (let i = 0; i < length; i++) {
+            const skip = (array[i] = this.next(min, max)) % 17n;
+            for (let ii = 0; ii < skip; ii++) this.next(min, max);
+        }
+        return array;
+    }
+}
+
+export class WeightedRandomRarity extends Random {
+    readonly #rarities: [string, number][];
+
+    constructor(rarities: { [rarity: string]: number }, seed = undefined) {
+        super(BigInt(seed ?? Date.now()));
+        const entries = Object.entries(Object.assign({}, rarities));
+        (this.#rarities = entries.map(([key, value]) => [key,
+            Math.trunc(value)])).forEach(([key, value]) => {
+            if (value < 0) throw new RangeError(`${key}: is negative`);
+        });
+    }
+
+    // @ts-expect-error
+    next(): string {
+        const entries = this.#rarities;
+        const total = this.cumulative();
+        const rand = super.next(0n, BigInt(total));
+        let cumulative = 0;
+        for (const [key, w] of entries) {
+            cumulative += w;
+            if (rand < cumulative) return key;
+        }
+        return entries[0][0];
+    }
+
+    cumulative(): number {
+        const entries = this.#rarities;
+        return entries.reduce((sum, [, value]) => sum + value, 0);
+    }
+
+    getOdds(): {
+        asPercents: { [rarity: string]: number },
+        asFloats: { [rarity: string]: number },
+        internal: { [rarity: string]: number }
+    } {
+        const total = this.cumulative();
+        const entries = this.#rarities, result: any = {
+            [Symbol.toStringTag]: "Rarities", total,
+            asPercents: {[Symbol.toStringTag]: "Rarities asPercents"},
+            asFloats: {[Symbol.toStringTag]: "Rarities asFloats"},
+            internal: {[Symbol.toStringTag]: "Rarities asFloats"},
+        };
+        for (const entry of entries) {
+            result.internal[entry[0]] = entry[1];
+            result.asFloats[entry[0]] = entry[1] / total;
+            const asPercent = ((entry[1] / total) * 100).toFixed(2) + '%';
+            result.asPercents[entry[0]] = asPercent.replace(/\.00%$/, '%');
+        }
+        Object.freeze(result.internal);
+        Object.freeze(result.asFloats);
+        Object.freeze(result.asPercents);
+        return Object.freeze(result);
+    }
+}

package/deepEquals.js

@@ -0,0 +1,34 @@
+// deeplyEquals
+export function deeplyEquals(le, ri, checkProto = false) {
+    if (le === ri)
+        return true;
+    if (le === null || ri === null)
+        return false;
+    if (typeof le !== typeof ri)
+        return false;
+    if (typeof le == "object" && typeof ri == "object") {
+        const leProps = sortAsStrings(Reflect.ownKeys(le));
+        const riProps = sortAsStrings(Reflect.ownKeys(ri));
+        if (leProps.length !== riProps.length)
+            return false;
+        for (let i = 0; i < leProps.length; i++) {
+            const key = leProps[i];
+            if (key !== riProps[i])
+                return false; // ensure same key names
+            if (!deeplyEquals(le[key], ri[key], checkProto))
+                return false;
+        }
+        if (checkProto)
+            return deeplyEquals(Object.getPrototypeOf(le), Object.getPrototypeOf(ri));
+        return true;
+    }
+    else
+        return false;
+}
+export function sortAsStrings(array) {
+    return Array.from(array, value => ({
+        value, toString() {
+            return String(this.value);
+        }
+    })).sort().map(({ value }) => value);
+}

package/deepEquals.ts

@@ -0,0 +1,26 @@
+// deeplyEquals
+export function deeplyEquals(le: any, ri: any, checkProto: boolean = false): boolean {
+    if (le === ri) return true;
+    if (le === null || ri === null) return false;
+    if (typeof le !== typeof ri) return false;
+    if (typeof le == "object" && typeof ri == "object") {
+        const leProps = sortAsStrings(Reflect.ownKeys(le));
+        const riProps = sortAsStrings(Reflect.ownKeys(ri));
+        if (leProps.length !== riProps.length) return false;
+        for (let i = 0; i < leProps.length; i++) {
+            const key = leProps[i];
+            if (key !== riProps[i]) return false; // ensure same key names
+            if (!deeplyEquals(le[key], ri[key], checkProto)) return false;
+        }
+        if (checkProto) return deeplyEquals(Object.getPrototypeOf(le), Object.getPrototypeOf(ri));
+        return true;
+    } else return false;
+}
+
+export function sortAsStrings<T>(array: T[]): T[] {
+    return Array.from(array, value => ({
+        value, toString() {
+            return String(this.value)
+        }
+    })).sort().map(({value}) => value);
+}

package/index.js

@@ -20,7 +20,7 @@ export function indent_codeblock(string) {
  * @param {string} string - The input string to format as a Markdown quote.
  * @returns {string} A string formatted as a Markdown blockquote.
  */
-function quoteMarkdown(string) {
+export function quoteMarkdown(string) {
     return '> ' + normalize_newlines(string).replace(/\n/g, '\n> ');
 }
 /**
@@ -28,9 +28,9 @@ function quoteMarkdown(string) {
  * Characters escaped include: ~ ` > - \ [ ] ( ) # ^ & * _ ! <
  *
  * @param {string} string - The input string to escape for Markdown.
- * @returns {string} The escaped string, safe for Markdown rendering.
+ * @reexport returns {string} The escaped string, safe for Markdown rendering.
  */
-function markdown_escape(string) {
+export function markdown_escape(string) {
     return normalize_newlines(string).replace(/[~`>\-\\\[\]()#^&*_!<]/g, '\\$&');
 }
 /**
@@ -54,3 +54,284 @@ export function jsonEncode(jsonicItem, indent = false, replacer) {
 export function jsonEncodeIndent(jsonicItem, indent = true, replacer) {
     return indent_codeblock(jsonEncode(jsonicItem, indent, replacer));
 }
+// CustomError
+export class CustomError extends Error {
+    detail;
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = new.target?.name ?? 'CustomError';
+    }
+    get [Symbol.toStringTag]() {
+        return this.name;
+    }
+    static [Symbol.toStringTag] = "CustomError";
+}
+export const EXMAScript = Object.freeze({
+    __proto__: {
+        [Symbol.toStringTag]: 'EXMAScriptInternals',
+    }, toIntegerOrInfinity(n) {
+        n = +n;
+        if (Object.is(n, NaN) || n === 0) {
+            return 0;
+        }
+        else
+            return Math.trunc(n);
+    }, OrdinaryToPrimitive(mixed, hint = "number") {
+        if (!["string", "number"].includes(hint))
+            throw new TypeError('incorrect hint');
+        if (!isObject(mixed))
+            return mixed;
+        const methodNames = hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"];
+        for (let methodName of methodNames) {
+            if (methodName in mixed) {
+                if (typeof mixed[methodName] === "function") {
+                    const primitive = mixed[methodName]();
+                    if (!isObject(primitive))
+                        return primitive;
+                }
+            }
+        }
+        throw new TypeError('could not convert to Primitive');
+    }, toPrimitive(value, hint) {
+        if (!["string", "number"].includes(hint))
+            throw new TypeError('incorrect hint');
+        let primitive;
+        if (value === null)
+            return "null";
+        if (typeof value === "object" || typeof value === "function") {
+            if (Symbol.toPrimitive in value && typeof value[Symbol.toPrimitive] === "function") {
+                primitive = value[Symbol.toPrimitive]('string');
+                if (isObject(primitive))
+                    throw new TypeError;
+            }
+            else {
+                primitive = EXMAScript.OrdinaryToPrimitive(value, "string");
+            }
+        }
+        else
+            primitive = value;
+        return primitive;
+    }, toPropertyKey(value) {
+        const primitive = EXMAScript.toPrimitive(value, "string");
+        if (typeof primitive === "symbol")
+            return primitive;
+        return String(primitive);
+    }, toNumeric(value) {
+        // Handle object conversion
+        value = EXMAScript.toPrimitive(value, "number");
+        if (typeof value === 'bigint')
+            return value;
+        else
+            return +value;
+    }, isNaN(nan) {
+        return isNaN(nan);
+    }, webBuiltins: Object.freeze({
+        [Symbol.toStringTag]: 'WebInternals',
+        TokenList: class TokenList {
+            #tokens;
+            constructor(array) {
+                this.#tokens = new Set(Array.from(array, s => `${s}`));
+            }
+            [Symbol.toStringTag] = 'TokenList';
+            toString() {
+                return Array.prototype.join.call(Array.from(this.#tokens.keys()), ' ');
+            }
+            add(...tokens) {
+                Array.from(tokens).forEach(s => this.#tokens.add(this._validateToken(s)));
+            }
+            contains(token) {
+                return this.#tokens.has(token);
+            }
+            remove(...tokens) {
+                Array.from(tokens).forEach(s => this.#tokens.delete(this._validateToken(s)));
+            }
+            toggle(token, force = undefined) {
+                token = this._validateToken(token);
+                if (this.contains(token)) {
+                    if (force === false || force === undefined) {
+                        this.remove(token);
+                        return false;
+                    }
+                    if (force) {
+                        this.add(token);
+                        return true;
+                    }
+                }
+            }
+            _validateToken(token) {
+                token = `${token}`;
+                if (token === '') {
+                    throw new EXMAScript.webBuiltins.SyntaxError('token is empty');
+                }
+                else if (/\s+/.test(token)) {
+                    throw new EXMAScript.webBuiltins.InvalidCharacterError('token is contains whitespace');
+                }
+                return token;
+            }
+            replace(oldToken, newToken) {
+                oldToken = this._validateToken(oldToken);
+                newToken = this._validateToken(newToken);
+                if (this.contains(oldToken)) {
+                    this.remove(oldToken);
+                    this.remove(newToken);
+                    return true;
+                }
+                return false;
+            }
+            get value() {
+                return this.toString();
+            }
+            get length() {
+                return this.#tokens.size;
+            }
+        },
+        SyntaxError: class extends CustomError {
+            constructor(m) {
+                super(m, '"SyntaxError" DOMException');
+            }
+        },
+        InvalidCharacterError: class extends CustomError {
+            constructor(m) {
+                super(m, '"InvalidCharacterError" DOMException');
+            }
+        },
+    }),
+});
+export function ResolveSecondsAfterNow(s = 0) {
+    return new Date((new Date).setMilliseconds(0) + (+s) * 1000);
+}
+/*
+function ResolveSecondsAfterNow(s=0){return new Date((new Date).setMilliseconds(0)+(+s)*1000)}
+*/
+export const mkJsonifable = ((Base) => class extends Base {
+    toJSON() {
+        const json = super.toJSON?.(...arguments);
+        if (json !== undefined)
+            return json;
+        return `${this}`;
+    }
+});
+// assignProperties.ts
+export function assignProperties(to, source, propertyNames) {
+    if (!isObject(to))
+        throw new TypeError('to isnt an object');
+    for (let properryObj of propertyNames) {
+        const property = EXMAScript.toPropertyKey(properryObj);
+        Reflect.set(to, property, Reflect.get(source, property));
+    }
+    return to;
+}
+export function isObject(value) {
+    if (value === null)
+        return false;
+    return (typeof value === "object" || typeof value === "function");
+}
+export function sortArray(array, key, converter) {
+    return Array.from(array, converter ?? (m => m)).map(value => ({
+        value, key: +Function.prototype.apply.call(key, value),
+    })).sort((a, b) => a.key - b.key).map(({ value }) => value);
+}
+export function getProperty(on, properties) {
+    const array = Array.from(properties, EXMAScript.toPropertyKey);
+    if (!isObject(on))
+        throw new TypeError;
+    let self = on;
+    for (let property of array) {
+        self = on;
+        on = Reflect.get(on, property);
+        if (on === null || on === undefined) {
+            const element = { result: undefined, self };
+            throw new CustomError(`couldnt read properties on (${on}) reading (${String(property)})`, element);
+        }
+    }
+    const result = on;
+    return { result, self };
+} // the result is the property, the self is the (this) value.
+export function allKeys(object) {
+    object = Object(object);
+    const result = Reflect.ownKeys(object);
+    while (object = Object.getPrototypeOf(object)) {
+        result.push(...Reflect.ownKeys(object));
+    }
+    return [...(new Set(result))];
+}
+export function isSafeIntegerRange(n) {
+    n = -(-n);
+    if (typeof n === "bigint") {
+        return n > Number.MIN_SAFE_INTEGER && n < Number.MAX_SAFE_INTEGER;
+    }
+    else
+        return Number.isSafeInteger(n);
+}
+export function NumericAbs(n) {
+    n = -n;
+    if (n < 0)
+        return -n;
+    return n;
+}
+export function getObjectType(o) {
+    const s = Object.prototype.toString.call(o);
+    return s.slice("[object ".length, -1);
+}
+export function countBooleansAndNullishItems(array) {
+    array = Array.from(array ?? [], b => (b === null || b === undefined) ? null : Boolean(b));
+    const result = { true: 0, false: 0, nullish: 0 };
+    for (let e of array) {
+        if (e === null)
+            result.nullish += 1;
+        else if (e)
+            result.true += 1;
+        else
+            result.false += 1;
+    }
+    return result;
+}
+export function removeDuplications(array) {
+    const dupe = Symbol("dupelication"), dupes = new Set;
+    return Array.from(array, function (m) {
+        if (dupes.has(m))
+            return dupe;
+        dupes.add(m);
+        return m;
+    }).filter(m => m !== dupe);
+}
+export function startOfDay(date) {
+    return (new Date(date ?? Date.now())).setHours(0, 0, 0, 0);
+}
+export function startOfDayUTC(date) {
+    return (new Date(date ?? Date.now())).setUTCHours(0, 0, 0, 0);
+}
+export class CounterItems {
+    #items = new Map;
+    [Symbol.toStringTag] = 'CounterItems';
+    add(object) {
+        if (!this.#items.has(object)) {
+            !this.#items.set(object, 0);
+        }
+        this.#items.set(object, this.#items.get(object) + 1);
+        return this;
+    }
+    set0(object) {
+        if (!this.#items.has(object)) {
+            !this.#items.set(object, 0);
+        }
+        return this;
+    }
+    get(object) {
+        return Number(this.#items.get(object));
+    }
+    toJSON() {
+        const obj = { __proto__: null };
+        for (const [key, value] of this.#items) {
+            if (typeof key === 'string') {
+                obj[key] = value;
+            }
+        }
+        return obj;
+    }
+    clear() {
+        this.#items.clear();
+        return this;
+    }
+}