@mtkruto/node 0.1.289 → 0.1.299

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/traversal.js

@@ -0,0 +1,101 @@
+import { isTag } from '../Node.js';
+const emptyArray = [];
+/**
+ * Get a node's children.
+ *
+ * @param elem Node to get the children of.
+ * @returns `elem`'s children, or an empty array.
+ */
+export function getChildren(elem) {
+    return elem.children ?? emptyArray;
+}
+/**
+ * Get a node's parent.
+ *
+ * @param elem Node to get the parent of.
+ * @returns `elem`'s parent node.
+ */
+export function getParent(elem) {
+    return elem.parent || null;
+}
+/**
+ * Gets an elements siblings, including the element itself.
+ *
+ * Attempts to get the children through the element's parent first.
+ * If we don't have a parent (the element is a root node),
+ * we walk the element's `prev` & `next` to get all remaining nodes.
+ *
+ * @param elem Element to get the siblings of.
+ * @returns `elem`'s siblings.
+ */
+export function getSiblings(elem) {
+    const parent = getParent(elem);
+    if (parent != null)
+        return getChildren(parent);
+    const siblings = [elem];
+    let { prev, next } = elem;
+    while (prev != null) {
+        siblings.unshift(prev);
+        ({ prev } = prev);
+    }
+    while (next != null) {
+        siblings.push(next);
+        ({ next } = next);
+    }
+    return siblings;
+}
+/**
+ * Gets an attribute from an element.
+ *
+ * @param elem Element to check.
+ * @param name Attribute name to retrieve.
+ * @returns The element's attribute value, or `undefined`.
+ */
+export function getAttributeValue(elem, name) {
+    return elem.attribs?.[name];
+}
+/**
+ * Checks whether an element has an attribute.
+ *
+ * @param elem Element to check.
+ * @param name Attribute name to look for.
+ * @returns Returns whether `elem` has the attribute `name`.
+ */
+export function hasAttrib(elem, name) {
+    return (elem.attribs != null &&
+        Object.prototype.hasOwnProperty.call(elem.attribs, name) &&
+        elem.attribs[name] != null);
+}
+/**
+ * Get the tag name of an element.
+ *
+ * @param elem The element to get the name for.
+ * @returns The tag name of `elem`.
+ */
+export function getName(elem) {
+    return elem.name;
+}
+/**
+ * Returns the next element sibling of a node.
+ *
+ * @param elem The element to get the next sibling of.
+ * @returns `elem`'s next sibling that is a tag.
+ */
+export function nextElementSibling(elem) {
+    let { next } = elem;
+    while (next !== null && !isTag(next))
+        ({ next } = next);
+    return next;
+}
+/**
+ * Returns the previous element sibling of a node.
+ *
+ * @param elem The element to get the previous sibling of.
+ * @returns `elem`'s previous sibling that is a tag.
+ */
+export function prevElementSibling(elem) {
+    let { prev } = elem;
+    while (prev !== null && !isTag(prev))
+        ({ prev } = prev);
+    return prev;
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/deflate.d.ts

@@ -24,4 +24,6 @@ export declare class Deflate {
     constructor(options?: DeflateOptions);
     push(data: Uint8Array, mode: boolean | number): Uint8Array;
 }
+export declare function deflate(input: Uint8Array, options?: DeflateOptions): Uint8Array;
+export declare function deflateRaw(input: Uint8Array, options?: DeflateOptions): Uint8Array;
 export declare function gzip(input: Uint8Array, options?: DeflateOptions): Uint8Array;

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/deflate.js

@@ -121,7 +121,7 @@ export class Deflate {
         return concatUint8Array(chunks);
     }
 }
-function deflate(input, options = {}) {
+export function deflate(input, options = {}) {
     const deflator = new Deflate(options);
     const result = deflator.push(input, true);
     // That will never happens, if you don't cheat with options :)
@@ -129,6 +129,10 @@ function deflate(input, options = {}) {
         throw deflator.msg || msg[deflator.err];
     return result;
 }
+export function deflateRaw(input, options = {}) {
+    options.raw = true;
+    return deflate(input, options);
+}
 export function gzip(input, options = {}) {
     options.gzip = true;
     return deflate(input, options);

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/inflate.d.ts

@@ -18,6 +18,6 @@ export declare class Inflate {
     constructor(options: InflateOptions);
     push(data: Uint8Array, mode: boolean | number): Uint8Array;
 }
-declare function inflate(input: Uint8Array, options?: InflateOptions): Uint8Array;
+export declare function inflate(input: Uint8Array, options?: InflateOptions): Uint8Array;
+export declare function inflateRaw(input: Uint8Array, options?: InflateOptions): Uint8Array;
 export declare const gunzip: typeof inflate;
-export {};

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/inflate.js

@@ -161,7 +161,7 @@ export class Inflate {
         return concatUint8Array(chunks);
     }
 }
-function inflate(input, options = {}) {
+export function inflate(input, options = {}) {
     const inflator = new Inflate(options);
     const result = inflator.push(input, true);
     // That will never happens, if you don't cheat with options :)
@@ -169,4 +169,8 @@ function inflate(input, options = {}) {
         throw inflator.msg || msg[inflator.err];
     return result;
 }
+export function inflateRaw(input, options = {}) {
+    options.raw = true;
+    return inflate(input, options);
+}
 export const gunzip = inflate;

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/zlib/crc32.js

@@ -5,7 +5,7 @@ export function makeTable() {
     for (let n = 0; n < 256; n++) {
         c = n;
         for (let k = 0; k < 8; k++) {
-            c = (c & 1) ? (m ^ (c >>> 1)) : (c >>> 1);
+            c = ((c & 1) ? (m ^ (c >>> 1)) : (c >>> 1));
         }
         table[n] = c;
     }

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/zlib/deflate.js

@@ -53,7 +53,7 @@ const MAX_BITS = 15;
 /* All codes must not exceed MAX_BITS bits */
 const MIN_MATCH = 3;
 const MAX_MATCH = 258;
-const MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
+const MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
 const PRESET_DICT = 0x20;
 const INIT_STATE = 42;
 const EXTRA_STATE = 69;
@@ -72,7 +72,7 @@ function err(strm, errorCode) {
     return errorCode;
 }
 function rank(f) {
-    return (f << 1) - (f > 4 ? 9 : 0);
+    return ((f) << 1) - ((f) > 4 ? 9 : 0);
 }
 function zero(buf) {
     buf.fill(0, 0, buf.length);
@@ -103,7 +103,7 @@ function flush_pending(strm) {
     }
 }
 function flush_block_only(s, last) {
-    trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);
+    trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last);
     s.block_start = s.strstart;
     flush_pending(s.strm);
 }
@@ -291,13 +291,13 @@ function fill_window(s) {
             p = n;
             do {
                 m = s.head[--p];
-                s.head[p] = m >= _w_size ? m - _w_size : 0;
+                s.head[p] = (m >= _w_size ? m - _w_size : 0);
             } while (--n);
             n = _w_size;
             p = n;
             do {
                 m = s.prev[--p];
-                s.prev[p] = m >= _w_size ? m - _w_size : 0;
+                s.prev[p] = (m >= _w_size ? m - _w_size : 0);
                 /* If n is not on any hash chain, prev[n] is garbage but
                  * its value will never be used.
                  */
@@ -578,7 +578,7 @@ function deflate_fast(s, flush) {
             /***/
         }
     }
-    s.insert = (s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1;
+    s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1);
     if (flush === STATUS.Z_FINISH) {
         /*** FLUSH_BLOCK(s, 1); ***/
         flush_block_only(s, true);
@@ -1437,7 +1437,7 @@ function deflateResetKeep(strm) {
         s.wrap = -s.wrap;
         /* was made negative by deflate(..., Z_FINISH); */
     }
-    s.status = s.wrap ? INIT_STATE : BUSY_STATE;
+    s.status = (s.wrap ? INIT_STATE : BUSY_STATE);
     strm.adler = (s.wrap === 2)
         ? 0 // crc32(0, Z_NULL, 0)
         : 1; // adler32(0, Z_NULL, 0)
@@ -1598,7 +1598,7 @@ export function deflate(strm, flush) {
             else {
                 level_flags = 3;
             }
-            header |= level_flags << 6;
+            header |= (level_flags << 6);
             if (s.strstart !== 0)
                 header |= PRESET_DICT;
             header += 31 - (header % 31);

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/zlib/inffast.js

@@ -313,8 +313,8 @@ export default function inflate_fast(strm, start) {
     /* update state and return */
     strm.next_in = _in;
     strm.next_out = _out;
-    strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
-    strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
+    strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
+    strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
     state.hold = hold;
     state.bits = bits;
     return;

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/zlib/inflate.js

@@ -618,7 +618,7 @@ export function inflate(strm, flush) {
                     break;
                 }
                 if (state.head) {
-                    state.head.text = (hold >> 8) & 1;
+                    state.head.text = ((hold >> 8) & 1);
                 }
                 if (state.flags & 0x0200) {
                     //=== CRC2(state.check, hold);
@@ -672,8 +672,8 @@ export function inflate(strm, flush) {
                 }
                 //===//
                 if (state.head) {
-                    state.head.xflags = hold & 0xff;
-                    state.head.os = hold >> 8;
+                    state.head.xflags = (hold & 0xff);
+                    state.head.os = (hold >> 8);
                 }
                 if (state.flags & 0x0200) {
                     //=== CRC2(state.check, hold);
@@ -829,7 +829,7 @@ export function inflate(strm, flush) {
                     //===//
                 }
                 if (state.head) {
-                    state.head.hcrc = (state.flags >> 9) & 1;
+                    state.head.hcrc = ((state.flags >> 9) & 1);
                     state.head.done = true;
                 }
                 strm.adler = state.check = 0;
@@ -889,7 +889,7 @@ export function inflate(strm, flush) {
                     bits += 8;
                 }
                 //===//
-                state.last = hold & 0x01 /*BITS(1)*/;
+                state.last = (hold & 0x01) /*BITS(1)*/;
                 //--- DROPBITS(1) ---//
                 hold >>>= 1;
                 bits -= 1;
@@ -1029,7 +1029,7 @@ export function inflate(strm, flush) {
                         bits += 8;
                     }
                     //===//
-                    state.lens[order[state.have++]] = hold & 0x07; //BITS(3);
+                    state.lens[order[state.have++]] = (hold & 0x07); //BITS(3);
                     //--- DROPBITS(3) ---//
                     hold >>>= 3;
                     bits -= 3;
@@ -1064,7 +1064,7 @@ export function inflate(strm, flush) {
                         here_bits = here >>> 24;
                         here_op = (here >>> 16) & 0xff;
                         here_val = here & 0xffff;
-                        if (here_bits <= bits)
+                        if ((here_bits) <= bits)
                             break;
                         //--- PULLBYTE() ---//
                         if (have === 0)
@@ -1338,7 +1338,7 @@ export function inflate(strm, flush) {
                     here_bits = here >>> 24;
                     here_op = (here >>> 16) & 0xff;
                     here_val = here & 0xffff;
-                    if (here_bits <= bits)
+                    if ((here_bits) <= bits)
                         break;
                     //--- PULLBYTE() ---//
                     if (have === 0)
@@ -1387,7 +1387,7 @@ export function inflate(strm, flush) {
                     break;
                 }
                 state.offset = here_val;
-                state.extra = here_op & 15;
+                state.extra = (here_op) & 15;
                 state.mode = DISTEXT;
             /* falls through */
             case DISTEXT:
@@ -1498,12 +1498,11 @@ export function inflate(strm, flush) {
                     strm.total_out += _out;
                     state.total += _out;
                     if (_out) {
-                        strm.adler =
-                            state.check =
-                                /*UPDATE(state.check, put - _out, _out);*/
-                                state.flags
-                                    ? crc32(state.check, output, _out, put - _out)
-                                    : adler32(state.check, output, _out, put - _out);
+                        strm.adler = state.check =
+                            /*UPDATE(state.check, put - _out, _out);*/
+                            (state.flags
+                                ? crc32(state.check, output, _out, put - _out)
+                                : adler32(state.check, output, _out, put - _out));
                     }
                     _out = left;
                     // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
@@ -1586,12 +1585,11 @@ export function inflate(strm, flush) {
     strm.total_out += _out;
     state.total += _out;
     if (state.wrap && _out) {
-        strm.adler =
-            state
-                .check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
-                state.flags
-                    ? crc32(state.check, output, _out, strm.next_out - _out)
-                    : adler32(state.check, output, _out, strm.next_out - _out);
+        strm.adler = state
+            .check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
+            (state.flags
+                ? crc32(state.check, output, _out, strm.next_out - _out)
+                : adler32(state.check, output, _out, strm.next_out - _out));
     }
     strm.data_type = state.bits + (state.last ? 64 : 0) +
         (state.mode === TYPE ? 128 : 0) +

package/esm/deps/raw.githubusercontent.com/MTKruto/compress/main/zlib/zlib/trees.js

@@ -261,7 +261,7 @@ function d_code(dist) {
 function put_short(s, w) {
     //    put_byte(s, (uch)((w) & 0xff));
     //    put_byte(s, (uch)((ush)(w) >> 8));
-    s.pending_buf[s.pending++] = w & 0xff;
+    s.pending_buf[s.pending++] = (w) & 0xff;
     s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
 }
 /* ===========================================================================
@@ -696,7 +696,7 @@ function build_tree(s, desc) {
      * two codes of non zero frequency.
      */
     while (s.heap_len < 2) {
-        node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
+        node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
         tree[node * 2] /*.Freq*/ = 1;
         s.depth[node] = 0;
         s.opt_len--;
@@ -709,7 +709,7 @@ function build_tree(s, desc) {
     /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
      * establish sub-heaps of increasing lengths:
      */
-    for (n = s.heap_len >> 1 /*int /2*/; n >= 1; n--)
+    for (n = (s.heap_len >> 1 /*int /2*/); n >= 1; n--)
         pqdownheap(s, tree, n);
     /* Construct the Huffman tree by repeatedly combining the least two
      * frequent nodes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtkruto/node",
-  "version": "0.1.289",
+  "version": "0.1.299",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "repository": {

package/script/client/4_client.js

@@ -1145,7 +1145,7 @@ class Client extends Composer {
                 if (!this.connected) {
                     continue;
                 }
-                __classPrivateFieldGet(this, _Client_pingLoopAbortController, "f").signal.throwIfAborted();
+                __classPrivateFieldGet(this, _Client_pingLoopAbortController, "f")?.signal.throwIfAborted();
                 await this.api.ping_delay_disconnect({ ping_id: (0, _1_utilities_js_1.getRandomId)(), disconnect_delay: __classPrivateFieldGet(this, _Client_pingInterval, "f") / 1000 + 15 });
                 if (Date.now() - __classPrivateFieldGet(this, _Client_lastUpdates, "f").getTime() >= 15 * 60 * 1000) {
                     (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _Client_updateManager, "f").recoverUpdateGap("lastUpdates"));

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.d.ts

@@ -0,0 +1,83 @@
+import { Node, Element, Document, NodeWithChildren, DataNode } from './Node.js';
+export interface DomHandlerOptions {
+    /**
+     * Add a `startIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `startIndex` is an integer
+     * indicating the position of the start of the node in the document.
+     *
+     * @default false
+     */
+    withStartIndices?: boolean;
+    /**
+     * Add an `endIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `endIndex` is an integer
+     * indicating the position of the end of the node in the document.
+     *
+     * @default false
+     */
+    withEndIndices?: boolean;
+    /**
+     * Replace all whitespace with single spaces.
+     *
+     * **Note:** Enabling this might break your markup.
+     *
+     * @default false
+     * @deprecated
+     */
+    normalizeWhitespace?: boolean;
+    /**
+     * Treat the markup as XML.
+     *
+     * @default false
+     */
+    xmlMode?: boolean;
+}
+interface ParserInterface {
+    startIndex: number | null;
+    endIndex: number | null;
+}
+type Callback = (error: Error | null, dom: Node[]) => void;
+type ElementCallback = (element: Element) => void;
+export declare class DomHandler {
+    /** The elements of the DOM */
+    dom: Node[];
+    /** The root element for the DOM */
+    root: Document;
+    /** Called once parsing has completed. */
+    private readonly callback;
+    /** Settings for the handler. */
+    private readonly options;
+    /** Callback whenever a tag is closed. */
+    private readonly elementCB;
+    /** Indicated whether parsing has been completed. */
+    private done;
+    /** Stack of open tags. */
+    protected tagStack: NodeWithChildren[];
+    /** A data node that is still being written to. */
+    protected lastNode: DataNode | null;
+    /** Reference to the parser instance. Used for location information. */
+    private parser;
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback?: Callback | null, options?: DomHandlerOptions | null, elementCB?: ElementCallback);
+    onparserinit(parser: ParserInterface): void;
+    onreset(): void;
+    onend(): void;
+    onerror(error: Error): void;
+    onclosetag(): void;
+    onopentag(name: string, attribs: {
+        [key: string]: string;
+    }): void;
+    ontext(data: string): void;
+    oncomment(data: string): void;
+    oncommentend(): void;
+    oncdatastart(): void;
+    oncdataend(): void;
+    onprocessinginstruction(name: string, data: string): void;
+    protected handleCallback(error: Error | null): void;
+    protected addNode(node: Node): void;
+}
+export default DomHandler;