skill-universe 1.1.0

package/build/dev/javascript/gleam_stdlib/gleam/bit_array.mjs

@@ -0,0 +1,285 @@
+import { Ok, toList, bitArraySlice, bitArraySliceToInt } from "../gleam.mjs";
+import * as $int from "../gleam/int.mjs";
+import * as $order from "../gleam/order.mjs";
+import * as $string from "../gleam/string.mjs";
+import {
+  bit_array_from_string as from_string,
+  bit_array_bit_size as bit_size,
+  bit_array_byte_size as byte_size,
+  bit_array_pad_to_bytes as pad_to_bytes,
+  bit_array_slice as slice,
+  bit_array_concat as concat,
+  base64_encode,
+  base64_decode as decode64,
+  base16_encode,
+  base16_decode,
+  bit_array_to_int_and_size,
+  bit_array_starts_with as starts_with,
+  bit_array_to_string as to_string,
+} from "../gleam_stdlib.mjs";
+
+export {
+  base16_decode,
+  base16_encode,
+  base64_encode,
+  bit_size,
+  byte_size,
+  concat,
+  from_string,
+  pad_to_bytes,
+  slice,
+  starts_with,
+  to_string,
+};
+
+/**
+ * Creates a new bit array by joining two bit arrays.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * append(to: from_string("butter"), suffix: from_string("fly"))
+ * // -> from_string("butterfly")
+ * ```
+ */
+export function append(first, second) {
+  return concat(toList([first, second]));
+}
+
+/**
+ * Decodes a base 64 encoded string into a `BitArray`.
+ */
+export function base64_decode(encoded) {
+  let _block;
+  let $ = byte_size(from_string(encoded)) % 4;
+  if ($ === 0) {
+    _block = encoded;
+  } else {
+    let n = $;
+    _block = $string.append(encoded, $string.repeat("=", 4 - n));
+  }
+  let padded = _block;
+  return decode64(padded);
+}
+
+/**
+ * Encodes a `BitArray` into a base 64 encoded string with URL and filename
+ * safe alphabet.
+ *
+ * If the bit array does not contain a whole number of bytes then it is padded
+ * with zero bits prior to being encoded.
+ */
+export function base64_url_encode(input, padding) {
+  let _pipe = input;
+  let _pipe$1 = base64_encode(_pipe, padding);
+  let _pipe$2 = $string.replace(_pipe$1, "+", "-");
+  return $string.replace(_pipe$2, "/", "_");
+}
+
+/**
+ * Decodes a base 64 encoded string with URL and filename safe alphabet into a
+ * `BitArray`.
+ */
+export function base64_url_decode(encoded) {
+  let _pipe = encoded;
+  let _pipe$1 = $string.replace(_pipe, "-", "+");
+  let _pipe$2 = $string.replace(_pipe$1, "_", "/");
+  return base64_decode(_pipe$2);
+}
+
+function inspect_loop(loop$input, loop$accumulator) {
+  while (true) {
+    let input = loop$input;
+    let accumulator = loop$accumulator;
+    if (input.bitSize === 0) {
+      return accumulator;
+    } else if (input.bitSize === 1) {
+      let x = bitArraySliceToInt(input, 0, 1, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(1)";
+    } else if (input.bitSize === 2) {
+      let x = bitArraySliceToInt(input, 0, 2, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(2)";
+    } else if (input.bitSize === 3) {
+      let x = bitArraySliceToInt(input, 0, 3, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(3)";
+    } else if (input.bitSize === 4) {
+      let x = bitArraySliceToInt(input, 0, 4, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(4)";
+    } else if (input.bitSize === 5) {
+      let x = bitArraySliceToInt(input, 0, 5, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(5)";
+    } else if (input.bitSize === 6) {
+      let x = bitArraySliceToInt(input, 0, 6, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(6)";
+    } else if (input.bitSize === 7) {
+      let x = bitArraySliceToInt(input, 0, 7, true, false);
+      return (accumulator + $int.to_string(x)) + ":size(7)";
+    } else if (input.bitSize >= 8) {
+      let x = input.byteAt(0);
+      let rest = bitArraySlice(input, 8);
+      let _block;
+      if (rest.bitSize === 0) {
+        _block = "";
+      } else {
+        _block = ", ";
+      }
+      let suffix = _block;
+      let accumulator$1 = (accumulator + $int.to_string(x)) + suffix;
+      loop$input = rest;
+      loop$accumulator = accumulator$1;
+    } else {
+      return accumulator;
+    }
+  }
+}
+
+/**
+ * Converts a bit array to a string containing the decimal value of each byte.
+ *
+ * Use this over `string.inspect` when you have a bit array you want printed
+ * in the array syntax even if it is valid UTF-8.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * inspect(<<0, 20, 0x20, 255>>)
+ * // -> "<<0, 20, 32, 255>>"
+ *
+ * inspect(<<100, 5:3>>)
+ * // -> "<<100, 5:size(3)>>"
+ * ```
+ */
+export function inspect(input) {
+  return inspect_loop(input, "<<") + ">>";
+}
+
+/**
+ * Compare two bit arrays as sequences of bytes.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * compare(<<1>>, <<2>>)
+ * // -> Lt
+ *
+ * compare(<<"AB":utf8>>, <<"AA":utf8>>)
+ * // -> Gt
+ *
+ * compare(<<1, 2:size(2)>>, with: <<1, 2:size(2)>>)
+ * // -> Eq
+ * ```
+ */
+export function compare(loop$a, loop$b) {
+  while (true) {
+    let a = loop$a;
+    let b = loop$b;
+    if (a.bitSize >= 8) {
+      if (b.bitSize >= 8) {
+        let first_byte = a.byteAt(0);
+        let first_rest = bitArraySlice(a, 8);
+        let second_byte = b.byteAt(0);
+        let second_rest = bitArraySlice(b, 8);
+        let f = first_byte;
+        let s = second_byte;
+        if (f > s) {
+          return new $order.Gt();
+        } else {
+          let f = first_byte;
+          let s = second_byte;
+          if (f < s) {
+            return new $order.Lt();
+          } else {
+            loop$a = first_rest;
+            loop$b = second_rest;
+          }
+        }
+      } else if (b.bitSize === 0) {
+        return new $order.Gt();
+      } else {
+        let first = a;
+        let second = b;
+        let $ = bit_array_to_int_and_size(first);
+        let $1 = bit_array_to_int_and_size(second);
+        let a$1 = $[0];
+        let b$1 = $1[0];
+        if (a$1 > b$1) {
+          return new $order.Gt();
+        } else {
+          let a$1 = $[0];
+          let b$1 = $1[0];
+          if (a$1 < b$1) {
+            return new $order.Lt();
+          } else {
+            let size_a = $[1];
+            let size_b = $1[1];
+            if (size_a > size_b) {
+              return new $order.Gt();
+            } else {
+              let size_a = $[1];
+              let size_b = $1[1];
+              if (size_a < size_b) {
+                return new $order.Lt();
+              } else {
+                return new $order.Eq();
+              }
+            }
+          }
+        }
+      }
+    } else if (b.bitSize === 0) {
+      if (a.bitSize === 0) {
+        return new $order.Eq();
+      } else {
+        return new $order.Gt();
+      }
+    } else if (a.bitSize === 0) {
+      return new $order.Lt();
+    } else {
+      let first = a;
+      let second = b;
+      let $ = bit_array_to_int_and_size(first);
+      let $1 = bit_array_to_int_and_size(second);
+      let a$1 = $[0];
+      let b$1 = $1[0];
+      if (a$1 > b$1) {
+        return new $order.Gt();
+      } else {
+        let a$1 = $[0];
+        let b$1 = $1[0];
+        if (a$1 < b$1) {
+          return new $order.Lt();
+        } else {
+          let size_a = $[1];
+          let size_b = $1[1];
+          if (size_a > size_b) {
+            return new $order.Gt();
+          } else {
+            let size_a = $[1];
+            let size_b = $1[1];
+            if (size_a < size_b) {
+              return new $order.Lt();
+            } else {
+              return new $order.Eq();
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Tests to see whether a bit array is valid UTF-8.
+ */
+export function is_utf8(bits) {
+  return is_utf8_loop(bits);
+}
+
+function is_utf8_loop(bits) {
+  let $ = to_string(bits);
+  if ($ instanceof Ok) {
+    return true;
+  } else {
+    return false;
+  }
+}

package/build/dev/javascript/gleam_stdlib/gleam/bool.mjs

@@ -0,0 +1,313 @@
+/**
+ * Returns the and of two bools, but it evaluates both arguments.
+ *
+ * It's the function equivalent of the `&&` operator.
+ * This function is useful in higher order functions or pipes.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * and(True, True)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * and(False, True)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * False |> and(True)
+ * // -> False
+ * ```
+ */
+export function and(a, b) {
+  return a && b;
+}
+
+/**
+ * Returns the or of two bools, but it evaluates both arguments.
+ *
+ * It's the function equivalent of the `||` operator.
+ * This function is useful in higher order functions or pipes.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * or(True, True)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * or(False, True)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * False |> or(True)
+ * // -> True
+ * ```
+ */
+export function or(a, b) {
+  return a || b;
+}
+
+/**
+ * Returns the opposite bool value.
+ *
+ * This is the same as the `!` or `not` operators in some other languages.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * negate(True)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * negate(False)
+ * // -> True
+ * ```
+ */
+export function negate(bool) {
+  return !bool;
+}
+
+/**
+ * Returns the nor of two bools.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * nor(False, False)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * nor(False, True)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * nor(True, False)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * nor(True, True)
+ * // -> False
+ * ```
+ */
+export function nor(a, b) {
+  return !(a || b);
+}
+
+/**
+ * Returns the nand of two bools.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * nand(False, False)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * nand(False, True)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * nand(True, False)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * nand(True, True)
+ * // -> False
+ * ```
+ */
+export function nand(a, b) {
+  return !(a && b);
+}
+
+/**
+ * Returns the exclusive or of two bools.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * exclusive_or(False, False)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * exclusive_or(False, True)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * exclusive_or(True, False)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * exclusive_or(True, True)
+ * // -> False
+ * ```
+ */
+export function exclusive_or(a, b) {
+  return a !== b;
+}
+
+/**
+ * Returns the exclusive nor of two bools.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * exclusive_nor(False, False)
+ * // -> True
+ * ```
+ *
+ * ```gleam
+ * exclusive_nor(False, True)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * exclusive_nor(True, False)
+ * // -> False
+ * ```
+ *
+ * ```gleam
+ * exclusive_nor(True, True)
+ * // -> True
+ * ```
+ */
+export function exclusive_nor(a, b) {
+  return a === b;
+}
+
+/**
+ * Returns a string representation of the given bool.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * to_string(True)
+ * // -> "True"
+ * ```
+ *
+ * ```gleam
+ * to_string(False)
+ * // -> "False"
+ * ```
+ */
+export function to_string(bool) {
+  if (bool) {
+    return "True";
+  } else {
+    return "False";
+  }
+}
+
+/**
+ * Run a callback function if the given bool is `False`, otherwise return a
+ * default value.
+ *
+ * With a `use` expression this function can simulate the early-return pattern
+ * found in some other programming languages.
+ *
+ * In a procedural language:
+ *
+ * ```js
+ * if (predicate) return value;
+ * // ...
+ * ```
+ *
+ * In Gleam with a `use` expression:
+ *
+ * ```gleam
+ * use <- guard(when: predicate, return: value)
+ * // ...
+ * ```
+ *
+ * Like everything in Gleam `use` is an expression, so it short circuits the
+ * current block, not the entire function. As a result you can assign the value
+ * to a variable:
+ *
+ * ```gleam
+ * let x = {
+ *   use <- guard(when: predicate, return: value)
+ *   // ...
+ * }
+ * ```
+ *
+ * Note that unlike in procedural languages the `return` value is evaluated
+ * even when the predicate is `False`, so it is advisable not to perform
+ * expensive computation nor side-effects there.
+ *
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let name = ""
+ * use <- guard(when: name == "", return: "Welcome!")
+ * "Hello, " <> name
+ * // -> "Welcome!"
+ * ```
+ *
+ * ```gleam
+ * let name = "Kamaka"
+ * use <- guard(when: name == "", return: "Welcome!")
+ * "Hello, " <> name
+ * // -> "Hello, Kamaka"
+ * ```
+ */
+export function guard(requirement, consequence, alternative) {
+  if (requirement) {
+    return consequence;
+  } else {
+    return alternative();
+  }
+}
+
+/**
+ * Runs a callback function if the given bool is `True`, otherwise runs an
+ * alternative callback function.
+ *
+ * Useful when further computation should be delayed regardless of the given
+ * bool's value.
+ *
+ * See [`guard`](#guard) for more info.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let name = "Kamaka"
+ * let inquiry = fn() { "How may we address you?" }
+ * use <- lazy_guard(when: name == "", return: inquiry)
+ * "Hello, " <> name
+ * // -> "Hello, Kamaka"
+ * ```
+ *
+ * ```gleam
+ * import gleam/int
+ *
+ * let name = ""
+ * let greeting = fn() { "Hello, " <> name }
+ * use <- lazy_guard(when: name == "", otherwise: greeting)
+ * let number = int.random(99)
+ * let name = "User " <> int.to_string(number)
+ * "Welcome, " <> name
+ * // -> "Welcome, User 54"
+ * ```
+ */
+export function lazy_guard(requirement, consequence, alternative) {
+  if (requirement) {
+    return consequence();
+  } else {
+    return alternative();
+  }
+}