windmill-cli 1.479.2 → 1.479.3

package/esm/deps/jsr.io/@std/encoding/1.0.4/_base32_common.js

@@ -0,0 +1,183 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright (c) 2014 Jameson Little. MIT License.
+// This module is browser compatible.
+/**
+ * common code for base32 and base32hex encodings.
+ */
+import { validateBinaryLike } from "./_validate_binary_like.js";
+const placeHolderPadLookup = [0, 1, , 2, 3, , 4];
+function getPadLength(placeHoldersLen) {
+    const maybeLen = placeHolderPadLookup[placeHoldersLen];
+    if (typeof maybeLen !== "number") {
+        throw new Error("Invalid pad length");
+    }
+    return maybeLen;
+}
+function getLens(b32) {
+    const len = b32.length;
+    if (len % 8 > 0) {
+        throw new Error(`Cannot decode base32 string as the length must be a multiple of 8: received length ${len}`);
+    }
+    let validLen = b32.indexOf("=");
+    if (validLen === -1)
+        validLen = len;
+    const placeHoldersLen = validLen === len ? 0 : 8 - (validLen % 8);
+    return [validLen, placeHoldersLen];
+}
+function getByteLength(validLen, placeHoldersLen) {
+    return ((validLen + placeHoldersLen) * 5) / 8 - getPadLength(placeHoldersLen);
+}
+/**
+ * Decodes an encoded string with the given lookup table.
+ *
+ * @param b32 The string to encode.
+ * @param lookup The lookup table
+ * @returns The encoded string.
+ */
+export function decode(b32, lookup) {
+    const revLookup = [];
+    lookup.forEach((c, i) => (revLookup[c.charCodeAt(0)] = i));
+    let tmp;
+    const [validLen, placeHoldersLen] = getLens(b32);
+    const arr = new Uint8Array(getByteLength(validLen, placeHoldersLen));
+    let curByte = 0;
+    // if there are placeholders, only get up to the last complete 8 chars
+    const len = placeHoldersLen > 0 ? validLen - 8 : validLen;
+    let i;
+    for (i = 0; i < len; i += 8) {
+        tmp = (revLookup[b32.charCodeAt(i)] << 20) |
+            (revLookup[b32.charCodeAt(i + 1)] << 15) |
+            (revLookup[b32.charCodeAt(i + 2)] << 10) |
+            (revLookup[b32.charCodeAt(i + 3)] << 5) |
+            revLookup[b32.charCodeAt(i + 4)];
+        arr[curByte++] = (tmp >> 17) & 0xff;
+        arr[curByte++] = (tmp >> 9) & 0xff;
+        arr[curByte++] = (tmp >> 1) & 0xff;
+        tmp = ((tmp & 1) << 15) |
+            (revLookup[b32.charCodeAt(i + 5)] << 10) |
+            (revLookup[b32.charCodeAt(i + 6)] << 5) |
+            revLookup[b32.charCodeAt(i + 7)];
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+    if (placeHoldersLen === 1) {
+        tmp = (revLookup[b32.charCodeAt(i)] << 20) |
+            (revLookup[b32.charCodeAt(i + 1)] << 15) |
+            (revLookup[b32.charCodeAt(i + 2)] << 10) |
+            (revLookup[b32.charCodeAt(i + 3)] << 5) |
+            revLookup[b32.charCodeAt(i + 4)];
+        arr[curByte++] = (tmp >> 17) & 0xff;
+        arr[curByte++] = (tmp >> 9) & 0xff;
+        arr[curByte++] = (tmp >> 1) & 0xff;
+        tmp = ((tmp & 1) << 7) |
+            (revLookup[b32.charCodeAt(i + 5)] << 2) |
+            (revLookup[b32.charCodeAt(i + 6)] >> 3);
+        arr[curByte++] = tmp & 0xff;
+    }
+    else if (placeHoldersLen === 3) {
+        tmp = (revLookup[b32.charCodeAt(i)] << 19) |
+            (revLookup[b32.charCodeAt(i + 1)] << 14) |
+            (revLookup[b32.charCodeAt(i + 2)] << 9) |
+            (revLookup[b32.charCodeAt(i + 3)] << 4) |
+            (revLookup[b32.charCodeAt(i + 4)] >> 1);
+        arr[curByte++] = (tmp >> 16) & 0xff;
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+    else if (placeHoldersLen === 4) {
+        tmp = (revLookup[b32.charCodeAt(i)] << 11) |
+            (revLookup[b32.charCodeAt(i + 1)] << 6) |
+            (revLookup[b32.charCodeAt(i + 2)] << 1) |
+            (revLookup[b32.charCodeAt(i + 3)] >> 4);
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+    else if (placeHoldersLen === 6) {
+        tmp = (revLookup[b32.charCodeAt(i)] << 3) |
+            (revLookup[b32.charCodeAt(i + 1)] >> 2);
+        arr[curByte++] = tmp & 0xff;
+    }
+    return arr;
+}
+function encodeChunk(uint8, start, end, lookup) {
+    let tmp;
+    const output = [];
+    for (let i = start; i < end; i += 5) {
+        tmp = ((uint8[i] << 16) & 0xff0000) |
+            ((uint8[i + 1] << 8) & 0xff00) |
+            (uint8[i + 2] & 0xff);
+        output.push(lookup[(tmp >> 19) & 0x1f]);
+        output.push(lookup[(tmp >> 14) & 0x1f]);
+        output.push(lookup[(tmp >> 9) & 0x1f]);
+        output.push(lookup[(tmp >> 4) & 0x1f]);
+        tmp = ((tmp & 0xf) << 16) |
+            ((uint8[i + 3] << 8) & 0xff00) |
+            (uint8[i + 4] & 0xff);
+        output.push(lookup[(tmp >> 15) & 0x1f]);
+        output.push(lookup[(tmp >> 10) & 0x1f]);
+        output.push(lookup[(tmp >> 5) & 0x1f]);
+        output.push(lookup[tmp & 0x1f]);
+    }
+    return output.join("");
+}
+/**
+ * Encodes the given data using the lookup table.
+ *
+ * @param data The data to encode.
+ * @param lookup The lookup table.
+ * @returns The encoded string.
+ */
+export function encode(data, lookup) {
+    const uint8 = validateBinaryLike(data);
+    let tmp;
+    const len = uint8.length;
+    const extraBytes = len % 5;
+    const parts = [];
+    const maxChunkLength = 16385; // must be multiple of 5
+    const len2 = len - extraBytes;
+    // go through the array every 5 bytes, we'll deal with trailing stuff later
+    for (let i = 0; i < len2; i += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength, lookup));
+    }
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 4) {
+        tmp = ((uint8[len2] & 0xff) << 16) |
+            ((uint8[len2 + 1] & 0xff) << 8) |
+            (uint8[len2 + 2] & 0xff);
+        parts.push(lookup[(tmp >> 19) & 0x1f]);
+        parts.push(lookup[(tmp >> 14) & 0x1f]);
+        parts.push(lookup[(tmp >> 9) & 0x1f]);
+        parts.push(lookup[(tmp >> 4) & 0x1f]);
+        tmp = ((tmp & 0xf) << 11) | (uint8[len2 + 3] << 3);
+        parts.push(lookup[(tmp >> 10) & 0x1f]);
+        parts.push(lookup[(tmp >> 5) & 0x1f]);
+        parts.push(lookup[tmp & 0x1f]);
+        parts.push("=");
+    }
+    else if (extraBytes === 3) {
+        tmp = ((uint8[len2] & 0xff) << 17) |
+            ((uint8[len2 + 1] & 0xff) << 9) |
+            ((uint8[len2 + 2] & 0xff) << 1);
+        parts.push(lookup[(tmp >> 20) & 0x1f]);
+        parts.push(lookup[(tmp >> 15) & 0x1f]);
+        parts.push(lookup[(tmp >> 10) & 0x1f]);
+        parts.push(lookup[(tmp >> 5) & 0x1f]);
+        parts.push(lookup[tmp & 0x1f]);
+        parts.push("===");
+    }
+    else if (extraBytes === 2) {
+        tmp = ((uint8[len2] & 0xff) << 12) | ((uint8[len2 + 1] & 0xff) << 4);
+        parts.push(lookup[(tmp >> 15) & 0x1f]);
+        parts.push(lookup[(tmp >> 10) & 0x1f]);
+        parts.push(lookup[(tmp >> 5) & 0x1f]);
+        parts.push(lookup[tmp & 0x1f]);
+        parts.push("====");
+    }
+    else if (extraBytes === 1) {
+        tmp = (uint8[len2] & 0xff) << 2;
+        parts.push(lookup[(tmp >> 5) & 0x1f]);
+        parts.push(lookup[tmp & 0x1f]);
+        parts.push("======");
+    }
+    return parts.join("");
+}

package/esm/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/_validate_binary_like.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 const encoder = new TextEncoder();
 function getTypeName(value) {
     const type = typeof value;

package/esm/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/ascii85.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 /**
  * Utilities for working with {@link https://en.wikipedia.org/wiki/Ascii85 | ascii85} encoding.

package/esm/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/base32.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // Copyright (c) 2014 Jameson Little. MIT License.
 // This module is browser compatible.
 /**
@@ -22,66 +22,48 @@
  *
  * @module
  */
-import { calcMax, decode, encode } from "./_common32.js";
-import { detach } from "./_common_detach.js";
-const padding = "=".charCodeAt(0);
-const alphabet = new TextEncoder()
-    .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
-const rAlphabet = new Uint8Array(128).fill(32); //alphabet.length
-alphabet.forEach((byte, i) => rAlphabet[byte] = i);
+import { decode, encode } from "./_base32_common.js";
+const lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567".split("");
+const revLookup = [];
+lookup.forEach((c, i) => (revLookup[c.charCodeAt(0)] = i));
 /**
- * Converts data into a base32-encoded string.
+ * Decodes a base32-encoded string.
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
  *
- * @param data The data to encode.
- * @returns The base32-encoded string.
+ * @param b32 The base32-encoded string to decode.
+ * @returns The decoded data.
  *
  * @example Usage
  * ```ts
- * import { encodeBase32 } from "@std/encoding/base32";
+ * import { decodeBase32 } from "@std/encoding/base32";
  * import { assertEquals } from "@std/assert";
  *
- * assertEquals(encodeBase32("6c60c0"), "GZRTMMDDGA======");
+ * assertEquals(
+ *   decodeBase32("GZRTMMDDGA======"),
+ *   new TextEncoder().encode("6c60c0"),
+ * );
  * ```
  */
-export function encodeBase32(data) {
-    if (typeof data === "string") {
-        data = new TextEncoder().encode(data);
-    }
-    else if (data instanceof ArrayBuffer)
-        data = new Uint8Array(data).slice();
-    else
-        data = data.slice();
-    const [output, i] = detach(data, calcMax(data.length));
-    encode(output, i, 0, alphabet, padding);
-    return new TextDecoder().decode(output);
+export function decodeBase32(b32) {
+    return decode(b32, lookup);
 }
 /**
- * Decodes a base32-encoded string.
+ * Converts data into a base32-encoded string.
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
  *
- * @param b32 The base32-encoded string to decode.
- * @returns The decoded data.
+ * @param data The data to encode.
+ * @returns The base32-encoded string.
  *
  * @example Usage
  * ```ts
- * import { decodeBase32 } from "@std/encoding/base32";
+ * import { encodeBase32 } from "@std/encoding/base32";
  * import { assertEquals } from "@std/assert";
  *
- * assertEquals(
- *   decodeBase32("GZRTMMDDGA======"),
- *   new TextEncoder().encode("6c60c0"),
- * );
+ * assertEquals(encodeBase32("6c60c0"), "GZRTMMDDGA======");
  * ```
  */
-export function decodeBase32(b32) {
-    const output = new TextEncoder().encode(b32);
-    if (output.length % 8) {
-        throw new TypeError(`Invalid base32 string: length (${output.length}) must be a multiple of 8`);
-    }
-    // deno-lint-ignore no-explicit-any
-    return new Uint8Array(output.buffer
-        .transfer(decode(output, 0, 0, rAlphabet, padding)));
+export function encodeBase32(data) {
+    return encode(data, lookup);
 }

package/esm/deps/jsr.io/@std/encoding/1.0.4/base32_stream.js

@@ -0,0 +1,92 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Utilities for encoding and decoding to and from base32 in a streaming manner.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @module
+ */
+import { decodeBase32, encodeBase32 } from "./base32.js";
+/**
+ * Converts a Uint8Array stream into a base32-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase32 } from "@std/encoding/base32";
+ * import { Base32EncoderStream } from "@std/encoding/base32-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new Base32EncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeBase32(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export class Base32EncoderStream extends TransformStream {
+    constructor() {
+        let push = new Uint8Array(0);
+        super({
+            transform(chunk, controller) {
+                const concat = new Uint8Array(push.length + chunk.length);
+                concat.set(push);
+                concat.set(chunk, push.length);
+                const remainder = -concat.length % 5;
+                controller.enqueue(encodeBase32(concat.slice(0, remainder || undefined)));
+                push = remainder ? concat.slice(remainder) : new Uint8Array(0);
+            },
+            flush(controller) {
+                if (push.length) {
+                    controller.enqueue(encodeBase32(push));
+                }
+            },
+        });
+    }
+}
+/**
+ * Decodes a base32-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { Base32DecoderStream } from "@std/encoding/base32-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["JBSWY3DPEBLW64TMMQQQ===="])
+ *   .pipeThrough(new Base32DecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello World!");
+ * ```
+ */
+export class Base32DecoderStream extends TransformStream {
+    constructor() {
+        let push = "";
+        super({
+            transform(chunk, controller) {
+                push += chunk;
+                if (push.length < 8) {
+                    return;
+                }
+                const remainder = -push.length % 8;
+                controller.enqueue(decodeBase32(push.slice(0, remainder || undefined)));
+                push = remainder ? chunk.slice(remainder) : "";
+            },
+            flush(controller) {
+                if (push.length) {
+                    controller.enqueue(decodeBase32(push));
+                }
+            },
+        });
+    }
+}

package/esm/deps/jsr.io/@std/encoding/1.0.4/base32hex.js

@@ -0,0 +1,77 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright (c) 2014 Jameson Little. MIT License.
+// This module is browser compatible.
+/**
+ * Utilities for
+ * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-7 | base32hex}
+ * encoding and decoding.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Modified from {@link [base32]}.
+ *
+ * This module is browser compatible.
+ *
+ * ```ts
+ * import { encodeBase32Hex, decodeBase32Hex } from "@std/encoding/base32hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase32Hex("foobar"), "CPNMUOJ1E8======");
+ *
+ * assertEquals(
+ *   decodeBase32Hex("CPNMUOJ1E8======"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ *
+ * @module
+ */
+import { decode, encode } from "./_base32_common.js";
+const lookup = "0123456789ABCDEFGHIJKLMNOPQRSTUV".split("");
+const revLookup = [];
+lookup.forEach((c, i) => revLookup[c.charCodeAt(0)] = i);
+/**
+ * Decodes a base32hex-encoded string.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-7}
+ *
+ * @param b32 The base32hex-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase32Hex } from "@std/encoding/base32hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase32Hex("6PHJCC3360======"),
+ *   new TextEncoder().encode("6c60c0"),
+ * );
+ * ```
+ */
+export function decodeBase32Hex(b32) {
+    return decode(b32, lookup);
+}
+/**
+ * Converts data into a base32hex-encoded string.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-7}
+ *
+ * @param data The data to encode.
+ * @returns The base32hex-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase32Hex } from "@std/encoding/base32hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase32Hex("6c60c0"), "6PHJCC3360======");
+ * ```
+ */
+export function encodeBase32Hex(data) {
+    return encode(data, lookup);
+}

package/esm/deps/jsr.io/@std/encoding/1.0.4/base32hex_stream.js

@@ -0,0 +1,92 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Utilities for encoding and decoding to and from base32hex in a streaming manner.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @module
+ */
+import { decodeBase32Hex, encodeBase32Hex } from "./base32hex.js";
+/**
+ * Converts a Uint8Array stream into a base32hex-encoded stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { encodeBase32Hex } from "@std/encoding/base32hex";
+ * import { Base32HexEncoderStream } from "@std/encoding/base32hex-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["Hello,", " world!"])
+ *   .pipeThrough(new TextEncoderStream())
+ *   .pipeThrough(new Base32HexEncoderStream());
+ *
+ * assertEquals(await toText(stream), encodeBase32Hex(new TextEncoder().encode("Hello, world!")));
+ * ```
+ */
+export class Base32HexEncoderStream extends TransformStream {
+    constructor() {
+        let push = new Uint8Array(0);
+        super({
+            transform(chunk, controller) {
+                const concat = new Uint8Array(push.length + chunk.length);
+                concat.set(push);
+                concat.set(chunk, push.length);
+                const remainder = -concat.length % 5;
+                controller.enqueue(encodeBase32Hex(concat.slice(0, remainder || undefined)));
+                push = remainder ? concat.slice(remainder) : new Uint8Array(0);
+            },
+            flush(controller) {
+                if (push.length) {
+                    controller.enqueue(encodeBase32Hex(push));
+                }
+            },
+        });
+    }
+}
+/**
+ * Decodes a base32hex-encoded stream into a Uint8Array stream.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @example Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { Base32HexDecoderStream } from "@std/encoding/base32hex-stream";
+ * import { toText } from "@std/streams/to-text";
+ *
+ * const stream = ReadableStream.from(["91IMOR3F5GG7ERRI", "DHI22==="])
+ *   .pipeThrough(new Base32HexDecoderStream())
+ *   .pipeThrough(new TextDecoderStream());
+ *
+ * assertEquals(await toText(stream), "Hello, world!");
+ * ```
+ */
+export class Base32HexDecoderStream extends TransformStream {
+    constructor() {
+        let push = "";
+        super({
+            transform(chunk, controller) {
+                push += chunk;
+                if (push.length < 8) {
+                    return;
+                }
+                const remainder = -push.length % 8;
+                controller.enqueue(decodeBase32Hex(push.slice(0, remainder || undefined)));
+                push = remainder ? chunk.slice(remainder) : "";
+            },
+            flush(controller) {
+                if (push.length) {
+                    controller.enqueue(decodeBase32Hex(push));
+                }
+            },
+        });
+    }
+}

package/esm/deps/jsr.io/@std/encoding/{1.0.8 → 1.0.4}/base58.js

@@ -1,4 +1,4 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 /**
  * Utilities for