@vbarbarosh/node-helpers 3.75.0 → 3.76.1

package/src/shell_curl_progress.md

@@ -0,0 +1,17 @@
+Runs a curl command and turns its progress meter into user-friendly status
+lines. `args` is the full command including the binary (`['curl', url, ...]`);
+`--no-silent --progress-meter` are appended, plus `-o /dev/null` when the args
+contain no `-o` (curl only prints a progress meter when the response body is
+redirected). stderr is parsed via `stream_curl_progress` and each row is
+reported as `user_friendly_status('42% | 587M of 3217M at 18.5M/s ETA 0:02:22
+duration=0:00:31')`; zero speed shows as `~`.
+
+Rejects when the process exits with a non-zero code or is killed by a signal
+(only exit code 0 is a success). Extra spawn options go under the `options`
+key of the second argument.
+
+## Signature
+
+```
+shell_curl_progress(args, {options, user_friendly_status}) → Promise<void>
+```

package/src/shell_lines.js

@@ -2,8 +2,8 @@ const shell = require('./shell');
 
 async function shell_lines(args, options)
 {
-    const s = await shell(args, options);
-    return s.trimEnd().split('\n');
+    const s = (await shell(args, options)).trimEnd();
+    return s === '' ? [] : s.split('\n');
 }
 
 module.exports = shell_lines;

package/src/shell_lines.md

@@ -3,7 +3,7 @@ Basic helper for running external commands via `execFile`, and splits stdout int
 - Fails if the command exits with non-zero code.
 - Fails if anything is printed to `stderr`.
 - Strips trailing newline(s).
-- Returns array of lines.
+- Returns array of lines; empty output produces `[]`, not `['']`.
 
 ## Signature
 

package/src/shell_spawn.js

@@ -35,6 +35,13 @@ function shell_spawn(args, options)
         run.reject = reject;
     });
 
+    // A spawn failure rejects both stages with the same error, and callers
+    // are expected to await only one of them (e.g. watchdog awaits init()
+    // alone): without a pre-registered handler the sibling rejection is
+    // reported as unhandled and can crash under --unhandled-rejections=strict.
+    init.promise.catch(ignore);
+    run.promise.catch(ignore);
+
     const out = child_process.spawn(args[0], args.slice(1), options);
     out.once('error', onerror);
     out.once('spawn', onspawn);

package/src/shell_ytdlp_progress.js

@@ -12,7 +12,8 @@ async function shell_ytdlp_progress(args, {user_friendly_status, ...options})
     const promises = [];
     promises.push(new Promise(function (resolve, reject) {
         proc.once('error', reject);
-        proc.once('exit', code => code ? reject(new Error(`Process terminated with code ${code}`)) : resolve());
+        // A signal-killed process exits with code = null: only 0 is a success
+        proc.once('exit', (code, signal) => code === 0 ? resolve() : reject(new Error(`Process terminated with code ${code} and signal ${signal}`)));
     }));
     promises.push(stream.promises.pipeline(proc.stdout, stream_ytdlp_progress(), stream_each(progress_fn)));
     promises.push(stream.promises.pipeline(proc.stderr, stream_each(v => console.log(`[stderr] ${v}`))));

package/src/shell_ytdlp_progress.md

@@ -0,0 +1,17 @@
+Runs the `yt-dlp` binary (hardcoded name, resolved via `PATH`) with
+`--progress` prepended to `args`, and turns its stdout progress lines into
+user-friendly status lines. Each parsed row (see `stream_ytdlp_progress`)
+is reported as `user_friendly_status('50.90% | [1/2] 8.0MB of 15.71MB at
+33.83MB/s ETA 00:01 duration=31s')`; the merging stage reports
+`'Merging... duration=...'`. `duration` is wall time since the spawn. stderr
+lines are echoed to the console with a `[stderr]` prefix.
+
+Rejects when the process exits with a non-zero code or is killed by a signal
+(only exit code 0 is a success). Extra properties of the second argument are
+passed through as spawn options.
+
+## Signature
+
+```
+shell_ytdlp_progress(args, {user_friendly_status, ...options}) → Promise<void>
+```

package/src/str_camel_to_snake.md

@@ -0,0 +1,11 @@
+Converts camelCase/PascalCase to snake_case and lowercases the result.
+Acronyms are kept together as one word (`SomeUPCCode` → `some_upc_code`),
+though an acronym at the end of the string has nothing to split it from the
+previous word (`thisISNT` → `this_isnt`).
+
+```js
+str_camel_to_snake('CamelCase')         // 'camel_case'
+str_camel_to_snake('SomeUPCCode')       // 'some_upc_code'
+str_camel_to_snake('thisISDifficult')   // 'this_is_difficult'
+str_camel_to_snake('UPC')               // 'upc'
+```

package/src/str_parse_kv.md

@@ -0,0 +1,11 @@
+Splits a `key: value` string on the first colon and returns a trimmed
+`[key, value]` pair. Only the first colon splits — the rest stays in the
+value — so URLs survive. Without a colon, the whole string is the key and
+the value is `''`.
+
+```js
+str_parse_kv('key: value')                  // ['key', 'value']
+str_parse_kv('url: http://example.com')     // ['url', 'http://example.com']
+str_parse_kv('key')                         // ['key', '']
+str_parse_kv(':value')                      // ['', 'value']
+```

package/src/stream_curl_progress.md

@@ -0,0 +1,14 @@
+Transform that parses curl's stderr progress meter (the `--progress-meter`
+table) into objects. The two header lines are skipped; every following line
+becomes `{perc, done, total, speed, eta, duration, time_total, ...}` with the
+raw columns (`recv`, `transferred`, `speed_down`, `speed_up`, ...) included.
+`done` is the received column, falling back to the transferred column while
+received is `'0'` (uploads). `--:--:--` times are reported as `'~'`.
+
+Lines starting with `curl:` (error messages) are written to
+`process.stderr` and dropped from the output.
+
+```js
+stream.compose(proc.stderr, stream_curl_progress())
+// {perc: '18', done: '587M', total: '3217M', speed: '19.0M', eta: '0:02:22', ...}
+```

package/src/stream_data_ln.js

@@ -1,3 +1,5 @@
+const {StringDecoder} = require('string_decoder');
+
 /**
  * Split stream on each \n and call `fn` for each line.
  *
@@ -7,6 +9,9 @@
  */
 function stream_data_ln(stream, fn)
 {
+    // StringDecoder buffers a multi-byte character split across chunk
+    // boundaries; plain buffer.toString('utf8') would corrupt it into �.
+    const decoder = new StringDecoder('utf8');
     let utf8 = '';
     stream.on('data', data);
     stream.on('end', end);
@@ -18,12 +23,13 @@ function stream_data_ln(stream, fn)
     }
     function end() {
         off();
+        utf8 += decoder.end();
         if (utf8) {
             fn(utf8, true);
         }
     }
     function data(buffer) {
-        utf8 += buffer.toString('utf8');
+        utf8 += (typeof buffer === 'string') ? buffer : decoder.write(buffer);
         for (let iteration = 1; true; ++iteration) {
             if (iteration == 1000000) {
                 throw new Error('Too many iterations');

package/src/stream_discard.md

@@ -0,0 +1,8 @@
+A writable sink that accepts and discards every chunk — useful to drain a
+pipeline whose output is irrelevant. Byte mode by default; pass
+`{objectMode: true}` for object streams. Consumes empty streams fine.
+
+```js
+await stream.promises.pipeline(source, stream_discard());
+await stream.promises.pipeline(objects, stream_discard({objectMode: true}));
+```

package/src/stream_group.md

@@ -0,0 +1,3 @@
+Deprecated alias of `stream_chunk` — splits an object stream into arrays of
+up to `chunk_size` items. Calls `stream_chunk(chunk_size)` directly; use
+`stream_chunk` in new code.

package/src/stream_gunzip.md

@@ -0,0 +1,7 @@
+Thin wrapper around `zlib.createGunzip(options)`: a transform that
+decompresses a gzipped byte stream. Corrupt input errors the stream
+(`incorrect header check`).
+
+```js
+await stream.promises.pipeline(gzipped_source, stream_gunzip(), destination);
+```

package/src/stream_hash.md

@@ -0,0 +1,10 @@
+Transform that consumes all input chunks and emits a single output chunk at
+flush: the hex digest of the whole stream. `algorithm` defaults to `'md5'`;
+any `crypto.createHash` algorithm name works, and `options` is passed
+through to it. An empty stream still emits the digest of empty input.
+
+```js
+const chunks = await stream.Readable.from(['aaa', 'bbb']).pipe(stream_hash('sha256')).toArray();
+Buffer.concat(chunks).toString('utf8');
+// '2ce109e9d0faf820b2434e166297934e6177b65ab9951dbc3e204cad4689b39c'
+```

package/src/stream_map.js

@@ -2,6 +2,10 @@ const stream = require('stream');
 
 /**
  * Transform each item using a simple function.
+ *
+ * Returning null or undefined from `fn` drops the item: streams cannot
+ * carry null (it is an eof mark), so pushing it would end the stream and
+ * silently discard everything after it.
  */
 function stream_map(fn)
 {
@@ -9,7 +13,10 @@ function stream_map(fn)
         objectMode: true,
         transform: async function (item, encoding, callback) {
             try {
-                this.push(await fn(item));
+                const out = await fn(item);
+                if (out !== null && out !== undefined) {
+                    this.push(out);
+                }
                 callback();
             }
             catch (error) {

package/src/stream_map_parallel.js

@@ -3,6 +3,10 @@ const stream = require('stream');
 
 /**
  * Transform each item using a simple function in parallel.
+ *
+ * Returning null or undefined from `handler` drops the item: streams cannot
+ * carry null (it is an eof mark), so pushing it would end the stream and
+ * silently discard everything after it.
  */
 function stream_map_parallel({handler, concurrency})
 {
@@ -46,7 +50,11 @@ function stream_map_parallel({handler, concurrency})
     function ready() {
         running--;
         while (buf.length && buf[0].isFulfilled()) {
-            out.push(buf.shift().value());
+            const value = buf.shift().value();
+            // null is an eof mark, pushing it would end the stream
+            if (value !== null && value !== undefined) {
+                out.push(value);
+            }
         }
         if (callback_next && buf.length < buf_limit) {
             const tmp = callback_next;

package/src/stream_md5.md

@@ -0,0 +1,9 @@
+Transform that consumes all input chunks and emits a single output chunk at
+flush: the md5 hex digest of the whole stream. An empty stream still emits
+`'d41d8cd98f00b204e9800998ecf8427e'`. Equivalent to `stream_hash('md5')`;
+the source carries a TODO to rename this to `stream_hash_md5`.
+
+```js
+const chunks = await stream.Readable.from(['aaa', 'bbb']).pipe(stream_md5()).toArray();
+Buffer.concat(chunks).toString('utf8');    // '6547436690a26a399603a7096e876a2d'
+```

package/src/stream_multiplex.js

@@ -3,6 +3,17 @@ const stream = require('stream');
 
 function stream_multiplex(...streams)
 {
+    if (streams.length === 0) {
+        // Multiplex of nothing is a sink which accepts and discards all writes
+        // (the generic write/final below would never invoke their callbacks).
+        return stream.Writable({
+            objectMode: true,
+            write: function (chunk, encoding, callback) {
+                callback();
+            },
+        });
+    }
+
     if (streams.length === 1) {
         return streams[0];
     }

package/src/stream_multiplex.md

@@ -0,0 +1,16 @@
+Combines several writable streams into one object-mode writable that
+duplicates every chunk to all of them. Backpressure is respected: a write
+completes only after every target accepted the chunk.
+
+- Zero streams → a sink that accepts and discards all writes.
+- One stream → returned as is (no wrapper).
+- Ending the multiplex ends all targets; destroying it destroys all targets.
+- An error in any target destroys the multiplex (and, through it, the other
+  targets) with that error — the first error wins.
+
+```js
+await stream.promises.pipeline(
+    source,
+    stream_multiplex(ws1, ws2),
+);
+```

package/src/stream_through.md

@@ -0,0 +1,3 @@
+Deprecated alias of `stream_tap` — calls `fn` on each item and passes the
+item through unchanged. Calls `stream_tap(fn)` directly; use `stream_tap`
+in new code.

package/src/stream_transform.md

@@ -0,0 +1,2 @@
+Deprecated alias of `stream_map` — maps each item through `fn`. Calls
+`stream_map(fn)` directly; use `stream_map` in new code.

package/src/stream_xml_analyze.js

@@ -1,5 +1,6 @@
 const htmlparser2 = require('htmlparser2');
 const stream = require('stream');
+const {StringDecoder} = require('string_decoder');
 
 /**
  * Consume XML, produce an object with analytics about provided xml stream.
@@ -30,13 +31,20 @@ function stream_xml_analyze()
     };
 
     const parser = new htmlparser2.Parser(events, options);
+    // StringDecoder buffers a multi-byte character split across chunk
+    // boundaries; plain buf.toString() would corrupt it into �.
+    const decoder = new StringDecoder('utf8');
     return out = new stream.Transform({
         objectMode: true,
         transform: function (buf, encoding, callback) {
-            parser.write(buf.toString());
+            parser.write(typeof buf === 'string' ? buf : decoder.write(buf));
             callback();
         },
         flush: function (callback) {
+            const tail = decoder.end();
+            if (tail) {
+                parser.write(tail);
+            }
             parser.end();
             callback();
         },

package/src/stream_xml_parse.js

@@ -2,6 +2,7 @@ const assert = require('assert');
 const const_stream = require('./const_stream');
 const htmlparser2 = require('htmlparser2');
 const stream = require('stream');
+const {StringDecoder} = require('string_decoder');
 
 /**
  * Consume XML, produce objects.
@@ -48,13 +49,20 @@ function stream_xml_parse(selector, mapper = stream_xml_parse.guess)
     };
 
     const parser = new htmlparser2.Parser(events, options);
+    // StringDecoder buffers a multi-byte character split across chunk
+    // boundaries; plain buf.toString() would corrupt it into �.
+    const decoder = new StringDecoder('utf8');
     return out = new stream.Transform({
         objectMode: true,
         transform: function (buf, encoding, callback) {
-            parser.write(buf.toString());
+            parser.write(typeof buf === 'string' ? buf : decoder.write(buf));
             callback();
         },
         flush: function (callback) {
+            const tail = decoder.end();
+            if (tail) {
+                parser.write(tail);
+            }
             parser.end();
             callback();
         },

package/src/stream_ytdlp_progress.js

@@ -55,7 +55,7 @@ function stream_ytdlp_progress()
                 current_part = downloading_formats.indexOf(m[1]) + 1;
                 return false;
             }
-            if (m = line.match(/^\[Merger]/i)) {
+            if (line.match(/^\[Merger]/i)) {
                 last.merging = true;
                 return last;
             }

package/src/stream_ytdlp_progress.md

@@ -0,0 +1,18 @@
+Transform that parses yt-dlp `--progress` output (stdout) into objects:
+`{current_part, total_parts, perc, done, total, speed, eta, merging}`. Sizes
+are re-formatted via `parse_bytes`/`format_bytes` (`15.71MiB` → `'15.71MB'`,
+`done` computed from the percentage), `Unknown` speed/ETA become `'~'`, and
+non-progress lines are dropped.
+
+- `[info] ...: Downloading N format(s): 251+248` plus the per-part
+  `[download] Destination: ....fNNN.ext` lines drive
+  `current_part`/`total_parts` for multi-format downloads (otherwise
+  `1`/`0`).
+- A `[Merger]` line re-emits the last row with `merging: true`. The last row
+  is mutated in place, so copy rows if you collect them.
+
+```js
+stream.Readable.from(lines).pipe(stream_ytdlp_progress())
+// {current_part: 1, total_parts: 0, perc: '50.90%', done: '8.0MB',
+//  total: '15.71MB', speed: '33.83MB/s', eta: '00:01', merging: false}
+```

package/src/strtr.js

@@ -2,13 +2,23 @@
 // echo strtr("hello", ["he" => "X", "hell" => "Y"]);
 function strtr(subject, map)
 {
-    let out = subject;
-    Object.entries(map).sort(fcmp).forEach(function ([search, replace]) {
-        out = out.replaceAll(search, replace);
-    });
+    // Single pass, like PHP: replaced text is never scanned again
+    const keys = Object.keys(map).filter(v => v.length).sort(fcmp);
+    let out = '';
+    for (let i = 0; i < subject.length; ) {
+        const key = keys.find(v => subject.startsWith(v, i));
+        if (key) {
+            out += map[key];
+            i += key.length;
+        }
+        else {
+            out += subject[i];
+            i++;
+        }
+    }
     return out;
     function fcmp(b, a) {
-        return a[0].length - b[0].length;
+        return a.length - b.length;
     }
 }
 

package/src/strtr.md

@@ -0,0 +1,11 @@
+Replaces substrings in `subject` using a `{from: to}` map, like PHP's
+`strtr`. Single pass: replaced text is never scanned again, so maps like
+`{a: 'b', b: 'c'}` cannot cascade. When keys overlap, the longest matching
+key wins regardless of map order. Empty keys are ignored.
+
+```js
+strtr('hello world', {world: 'there'})  // 'hello there'
+strtr('hello', {he: 'X', hell: 'Y'})    // 'Yo' (longest key wins)
+strtr('ab', {a: 'b', b: 'c'})           // 'bc' (single pass, no cascade)
+strtr('hello', {l: ''})                 // 'heo'
+```

package/src/urlclean.js

@@ -6,6 +6,13 @@ const querystring = require('querystring');
  */
 function urlclean(url)
 {
+    // The #fragment is not part of the query string: without splitting it
+    // off first it would be percent-encoded into the last query value.
+    const h = url.indexOf('#');
+    const hash = (h === -1) ? '' : url.slice(h);
+    if (hash) {
+        url = url.slice(0, h);
+    }
     const i = url.indexOf('?') + 1;
     if (i) {
         const s = querystring.stringify(querystring.parse(url.slice(i)), '&', '=', {
@@ -13,9 +20,9 @@ function urlclean(url)
                 return encodeURIComponent(v).replaceAll('%3A', ':').replaceAll('%2F', '/');
             },
         });
-        return url.slice(0, i) + s;
+        return url.slice(0, i) + s + hash;
     }
-    return url;
+    return url + hash;
 }
 
 module.exports = urlclean;

package/src/urlmod.js

@@ -7,29 +7,40 @@
  */
 function urlmod(url, params)
 {
-    const tmp_url = new URL(url||'', 'xxx://___base___/');
-    const tmp_search = tmp_url.searchParams;
-    Object.entries(params || {}).forEach(function ([key, value]) {
+    const input_url = String(url || '');
+    const entries = Object.entries(params || {});
+    if (!entries.length) {
+        return input_url;
+    }
+
+    const hash_pos = input_url.indexOf('#');
+    const hash = hash_pos === -1 ? '' : input_url.slice(hash_pos);
+    const before_hash = hash_pos === -1 ? input_url : input_url.slice(0, hash_pos);
+    const query_pos = before_hash.indexOf('?');
+    const before_query = query_pos === -1 ? before_hash : before_hash.slice(0, query_pos);
+    const query = query_pos === -1 ? '' : before_hash.slice(query_pos + 1);
+    const search = new URLSearchParams(query);
+
+    entries.forEach(function ([key, value]) {
         switch (value) {
         case null:
         case undefined:
-            tmp_search.delete(key);
+            search.delete(key);
             break;
         case true:
-            tmp_search.set(key, 1);
+            search.set(key, '1');
             break;
         case false:
-            tmp_search.set(key, 0);
+            search.set(key, '0');
             break;
         default:
-            tmp_search.set(key, value);
+            search.set(key, String(value));
             break;
         }
     });
-    if (url && url[0] === '/') {
-        return tmp_url.toString().replace(/^xxx:\/\/___base___/, '');
-    }
-    return tmp_url.toString().replace(/^xxx:\/\/___base___\//, '');
+
+    const output_query = search.toString();
+    return before_query + (output_query ? `?${output_query}` : '') + hash;
 }
 
 module.exports = urlmod;

package/src/urlmod.md

@@ -1,7 +1,19 @@
 Set, change, or remove query string parameters.
 
+Only the query string is parsed and rebuilt. The URL text before `?` and the
+fragment starting with `#` are preserved, so absolute, relative,
+protocol-relative, and non-standard URL-like strings are supported. Passing no
+parameters, or an empty parameters object, returns the input unchanged.
+
+`null` and `undefined` remove a parameter. Boolean values are encoded as `1`
+and `0`; other values use the standard `URLSearchParams` conversion and
+encoding rules.
+
 ```js
-urlmod('', {a: 1})          // '?a=1'  set
-urlmod('?a=1', {a: 2})      // '?a=2'  change
-urlmod('?a=1', {a: null})   // ''      remove
+urlmod('', {a: 1})                      // '?a=1'
+urlmod('?a=1', {a: 2})                  // '?a=2'
+urlmod('?a=1#top', {a: null})           // '#top'
+urlmod('../api?old=1', {old: 2})        // '../api?old=2'
+urlmod('//cdn.example/app.js', {v: 2})  // '//cdn.example/app.js?v=2'
+urlmod('/search', {exact: true})        // '/search?exact=1'
 ```

package/src/urlparts.md

@@ -0,0 +1,17 @@
+Splits a URL into a fixed-shape plain object. Accepts a `URL` instance or a
+string; strings are parsed against the base `fake://fake/`, so relative paths
+work (and non-string input degrades to the bare base instead of throwing).
+The keys mirror the `URL` properties, except `pathname` is exposed as `path`.
+
+```js
+urlparts('https://john:secret@example.com:8080/users/15?page=2#top')
+// {
+//     href: 'https://john:secret@example.com:8080/users/15?page=2#top',
+//     protocol: 'https:', hostname: 'example.com',
+//     username: 'john', password: 'secret',
+//     host: 'example.com:8080', port: '8080',
+//     path: '/users/15', search: '?page=2', hash: '#top',
+// }
+urlparts('/users?page=5').path      // '/users'
+urlparts('/users?page=5').protocol  // 'fake:'
+```

package/src/wait_while.js

@@ -1,7 +1,7 @@
 const Promise = require('bluebird');
 
 /**
- * Wait until `fn` returns `true`.
+ * Wait while `fn` returns a truthy value; resolve as soon as it turns falsy.
  *
  * W A R N I N G
  * This method was designed mainly for prototyping (where code cleanliness is important).

package/src/wait_while.md

@@ -1,4 +1,4 @@
-Wait until `fn` returns `true`.
+Wait while `fn` returns a truthy value; resolve as soon as it turns falsy.
 
 W A R N I N G
 This method was designed mainly for prototyping (where code cleanliness is important).

package/src/HeartbeatServer.test.js

@@ -1,31 +0,0 @@
-const HeartbeatServer = require('./HeartbeatServer');
-const assert = require('assert');
-const fs_assert_file_socket = require('./fs_assert_file_socket');
-const ping_socket = require('./ping_socket');
-
-// 💎 Only the lack of a valid PING within WATCHDOG_INTERVAL is fatal
-
-// 📕 Notes by ChatGPT
-// If listen() fails (EADDRINUSE, perms, etc.), constructor will throw,
-// and heartbeat_server will be undefined in finally { await heartbeat_server.dispose() }.
-
-describe('HeartbeatServer', function () {
-    it('Happy Path', async function () {
-        const server = new HeartbeatServer();
-        try {
-            let counter = 0;
-            server.on('heartbeat', () => counter++);
-            await fs_assert_file_socket(server.socket_path);
-            await ping_socket(server.socket_path);
-            await ping_socket(server.socket_path);
-            assert.strictEqual(counter, 2);
-        }
-        finally {
-            await server.dispose();
-        }
-    });
-
-    // should emit a "warning" event on any client errors
-    // should not send any heartbeat signals after rejection (decision to kill a child process)
-    // should reject when no heartbeat received in an expected interval
-});

package/src/array_chunk.test.js

@@ -1,24 +0,0 @@
-const array_chunk = require('./array_chunk');
-const assert = require('assert');
-
-describe('array_chunk', function () {
-    it('should accept no arguments', function () {
-        assert.deepStrictEqual(array_chunk(), []);
-    });
-    it('should handle basic input', function () {
-        assert.deepStrictEqual(array_chunk([]), []);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5]), [[1],[2],[3],[4],[5]]);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5], 1), [[1],[2],[3],[4],[5]]);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5], 2), [[1,2],[3,4],[5]]);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5], 3), [[1,2,3],[4,5]]);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5], 4), [[1,2,3,4],[5]]);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5], 5), [[1,2,3,4,5]]);
-        assert.deepStrictEqual(array_chunk([1,2,3,4,5], 6), [[1,2,3,4,5]]);
-    });
-    it('should throw when limit is less than 1', function () {
-        assert.throws(() => array_chunk([], 0));
-        assert.throws(() => array_chunk([], -1));
-        assert.throws(() => array_chunk([1], 0));
-        assert.throws(() => array_chunk([1], -1));
-    });
-});