gossamer

// src/gossamer/uint8_array.ffi.ts
import * as $order from "../../gleam_stdlib/gleam/order.mjs";

// src/utils/list.ts
import {
  List$Empty,
  List$isNonEmpty,
  List$NonEmpty,
  List$NonEmpty$first,
  List$NonEmpty$rest
} from "../../prelude.mjs";
function fromArray(array) {
  let list = List$Empty();
  for (let i = array.length - 1; i >= 0; --i) {
    list = List$NonEmpty(array[i], list);
  }
  return list;
}
function toArray(list) {
  const array = [];
  let current = list;
  while (List$isNonEmpty(current)) {
    array.push(List$NonEmpty$first(current));
    current = List$NonEmpty$rest(current);
  }
  return array;
}

// src/utils/result.ts
import { Result$Error, Result$Ok } from "../../prelude.mjs";
function toResult(value) {
  return value === null || value === void 0 ? Result$Error(void 0) : Result$Ok(value);
}
toResult.fromThrows = function(throws) {
  try {
    return Result$Ok(throws());
  } catch (error) {
    return Result$Error(
      error instanceof Error ? error.message : String(error)
    );
  }
};
toResult.fromPromise = function(promise) {
  return promise.then(
    (value) => Result$Ok(value),
    (error) => Result$Error(error instanceof Error ? error.message : String(error))
  );
};

// src/gossamer/uint8_array.ffi.ts
var new_ = () => {
  return new Uint8Array();
};
var from_length = (length2) => {
  return new Uint8Array(length2);
};
var from_list = (list) => {
  return new Uint8Array(toArray(list));
};
var from_list_mapped = (list, mapper) => {
  return Uint8Array.from(toArray(list), mapper);
};
var from_buffer = (buffer2) => {
  return new Uint8Array(buffer2);
};
var buffer = (array) => {
  return array.buffer;
};
var byte_length = (array) => {
  return array.byteLength;
};
var byte_offset = (array) => {
  return array.byteOffset;
};
var length = (array) => {
  return array.length;
};
var at = (array, index) => {
  return toResult(array.at(index));
};
var includes = (array, value) => {
  return array.includes(value);
};
var includes_from = (array, value, index) => {
  return array.includes(value, index);
};
var index_of = (array, value) => {
  return array.indexOf(value);
};
var index_of_from = (array, value, index) => {
  return array.indexOf(value, index);
};
var last_index_of = (array, value) => {
  return array.lastIndexOf(value);
};
var last_index_of_from = (array, value, index) => {
  return array.lastIndexOf(value, index);
};
var slice = (array) => {
  return array.slice();
};
var slice_from = (array, start) => {
  return array.slice(start);
};
var slice_range = (array, start, end) => {
  return array.slice(start, end);
};
var subarray = (array, begin, end) => {
  return array.subarray(begin, end);
};
var set = (array, values2) => {
  array.set(values2);
};
var set_with_offset = (array, values2, offset) => {
  array.set(values2, offset);
};
var copy_within = (array, target, start) => {
  return array.copyWithin(target, start);
};
var copy_within_range = (array, target, start, end) => {
  return array.copyWithin(target, start, end);
};
var fill = (array, value) => {
  return array.fill(value);
};
var fill_range = (array, value, start, end) => {
  return array.fill(value, start, end);
};
var reverse = (array) => {
  return array.reverse();
};
var with_ = (array, index, value) => {
  return array.with(index, value);
};
var join = (array, separator) => {
  return array.join(separator);
};
var every = (array, predicate) => {
  return array.every((value) => predicate(value));
};
var index_every = (array, predicate) => {
  return array.every((value, index) => predicate(value, index));
};
var some = (array, predicate) => {
  return array.some((value) => predicate(value));
};
var index_some = (array, predicate) => {
  return array.some((value, index) => predicate(value, index));
};
var find = (array, predicate) => {
  return toResult(array.find((value) => predicate(value)));
};
var index_find = (array, predicate) => {
  return toResult(array.find((value, index) => predicate(value, index)));
};
var find_index = (array, predicate) => {
  return array.findIndex((value) => predicate(value));
};
var index_find_index = (array, predicate) => {
  return array.findIndex((value, index) => predicate(value, index));
};
var find_last = (array, predicate) => {
  return toResult(array.findLast((value) => predicate(value)));
};
var index_find_last = (array, predicate) => {
  return toResult(array.findLast((value, index) => predicate(value, index)));
};
var find_last_index = (array, predicate) => {
  return array.findLastIndex((value) => predicate(value));
};
var index_find_last_index = (array, predicate) => {
  return array.findLastIndex((value, index) => predicate(value, index));
};
var filter = (array, predicate) => {
  return array.filter((value) => predicate(value));
};
var index_filter = (array, predicate) => {
  return array.filter((value, index) => predicate(value, index));
};
var map = (array, callback) => {
  return array.map((value) => callback(value));
};
var index_map = (array, callback) => {
  return array.map((value, index) => callback(value, index));
};
var for_each = (array, callback) => {
  array.forEach((value) => callback(value));
};
var index_for_each = (array, callback) => {
  array.forEach((value, index) => callback(value, index));
};
function toCompareFn(compare) {
  return (a, b) => {
    const result = compare(a, b);
    if ($order.Order$isLt(result)) return -1;
    if ($order.Order$isGt(result)) return 1;
    return 0;
  };
}
var sort = (array, compare) => {
  return array.sort(toCompareFn(compare));
};
var to_sorted = (array, compare) => {
  return array.toSorted(toCompareFn(compare));
};
var to_reversed = (array) => {
  return array.toReversed();
};
var reduce = (array, initial, callback) => {
  return array.reduce(
    (acc, value) => callback(acc, value),
    initial
  );
};
var reduce_right = (array, initial, callback) => {
  return array.reduceRight(
    (acc, value) => callback(acc, value),
    initial
  );
};
var index_reduce = (array, initial, callback) => {
  return array.reduce(
    (acc, value, index) => callback(acc, value, index),
    initial
  );
};
var index_reduce_right = (array, initial, callback) => {
  return array.reduceRight(
    (acc, value, index) => callback(acc, value, index),
    initial
  );
};
var keys = (array) => {
  return fromArray(Array.from(array.keys()));
};
var values = (array) => {
  return fromArray(Array.from(array.values()));
};
var entries = (array) => {
  return fromArray(Array.from(array.entries()));
};
var to_list = (array) => {
  return fromArray(Array.from(array));
};
var to_base64 = (array) => {
  return array.toBase64();
};
var to_hex = (array) => {
  return array.toHex();
};
var from_base64 = (string) => {
  return Uint8Array.fromBase64(string);
};
var from_hex = (string) => {
  return Uint8Array.fromHex(string);
};
var set_from_base64 = (array, string) => {
  const result = array.setFromBase64(string);
  return [result.read, result.written];
};
var set_from_hex = (array, string) => {
  const result = array.setFromHex(string);
  return [result.read, result.written];
};
export {
  at,
  buffer,
  byte_length,
  byte_offset,
  copy_within,
  copy_within_range,
  entries,
  every,
  fill,
  fill_range,
  filter,
  find,
  find_index,
  find_last,
  find_last_index,
  for_each,
  from_base64,
  from_buffer,
  from_hex,
  from_length,
  from_list,
  from_list_mapped,
  includes,
  includes_from,
  index_every,
  index_filter,
  index_find,
  index_find_index,
  index_find_last,
  index_find_last_index,
  index_for_each,
  index_map,
  index_of,
  index_of_from,
  index_reduce,
  index_reduce_right,
  index_some,
  join,
  keys,
  last_index_of,
  last_index_of_from,
  length,
  map,
  new_,
  reduce,
  reduce_right,
  reverse,
  set,
  set_from_base64,
  set_from_hex,
  set_with_offset,
  slice,
  slice_from,
  slice_range,
  some,
  sort,
  subarray,
  to_base64,
  to_hex,
  to_list,
  to_reversed,
  to_sorted,
  values,
  with_
};