[T; N] {\\n /// Returns the length of this array.\\n ///\\n /// ```noir\\n /// fn len(self) -> Field\\n /// ```\\n ///\\n /// example\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let array = [42, 42];\\n /// assert(array.len() == 2);\\n /// }\\n /// ```\\n #[builtin(array_len)]\\n pub fn len(self) -> u32 {}\\n\\n /// Returns this array as a slice.\\n ///\\n /// ```noir\\n /// let array = [1, 2];\\n /// let slice = array.as_slice();\\n /// assert_eq(slice, &[1, 2]);\\n /// ```\\n #[builtin(as_slice)]\\n pub fn as_slice(self) -> [T] {}\\n\\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.map(|a| a * 2);\\n /// assert_eq(b, [2, 4, 6]);\\n /// ```\\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array along with its index,\\n /// returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.mapi(|i, a| i + a * 2);\\n /// assert_eq(b, [2, 5, 8]);\\n /// ```\\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(i, self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// let mut i = 0;\\n /// a.for_each(|x| {\\n /// b[i] = x;\\n /// i += 1;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\\n for i in 0..self.len() {\\n f(self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of this array along with its index.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// a.for_eachi(|i, x| {\\n /// b[i] = x;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\\n for i in 0..self.len() {\\n f(i, self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of the array, returning the final accumulated value. The first\\n /// parameter is the initial value.\\n ///\\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\\n ///\\n /// ```rust\\n /// let a1 = [1];\\n /// let a2 = [1, 2];\\n /// let a3 = [1, 2, 3];\\n ///\\n /// let f = |a, b| a - b;\\n /// a1.fold(10, f); //=> f(10, 1)\\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\\n ///\\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\\n /// ```\\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\\n for elem in self {\\n accumulator = f(accumulator, elem);\\n }\\n accumulator\\n }\\n\\n /// Same as fold, but uses the first element as the starting element.\\n ///\\n /// Requires the input array to be non-empty.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [1, 2, 3, 4];\\n /// let reduced = arr.reduce(|a, b| a + b);\\n /// assert(reduced == 10);\\n /// }\\n /// ```\\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\\n let mut accumulator = self[0];\\n for i in 1..self.len() {\\n accumulator = f(accumulator, self[i]);\\n }\\n accumulator\\n }\\n\\n /// Returns true if all the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 2];\\n /// let all = arr.all(|a| a == 2);\\n /// assert(all);\\n /// }\\n /// ```\\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = true;\\n for elem in self {\\n ret &= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Returns true if any of the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 5];\\n /// let any = arr.any(|a| a == 5);\\n /// assert(any);\\n /// }\\n /// ```\\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = false;\\n for elem in self {\\n ret |= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Concatenates this array with another array.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr1 = [1, 2, 3, 4];\\n /// let arr2 = [6, 7, 8, 9, 10, 11];\\n /// let concatenated_arr = arr1.concat(arr2);\\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n /// }\\n /// ```\\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\\n let mut result = [crate::mem::zeroed(); N + M];\\n for i in 0..N {\\n result[i] = self[i];\\n }\\n for i in 0..M {\\n result[i + N] = array2[i];\\n }\\n result\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Ord + Eq,\\n{\\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\\n /// sort any type, you should use the `sort_via` function.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32];\\n /// let sorted = arr.sort();\\n /// assert(sorted == [32, 42]);\\n /// }\\n /// ```\\n pub fn sort(self) -> Self {\\n self.sort_via(|a, b| a <= b)\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Eq,\\n{\\n /// Returns a new sorted array by sorting it with a custom comparison function.\\n /// The original array remains untouched.\\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\\n ///\\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32]\\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\\n /// assert(sorted_ascending == [32, 42]); // verifies\\n ///\\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\\n /// assert(sorted_descending == [32, 42]); // does not verify\\n /// }\\n /// ```\\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\\n // Safety: `sorted` array is checked to be:\\n // a. a permutation of `input`'s elements\\n // b. satisfying the predicate `ordering`\\n unsafe {\\n let sorted = quicksort::quicksort(self, ordering);\\n\\n if !is_unconstrained() {\\n for i in 0..N - 1 {\\n assert(\\n ordering(sorted[i], sorted[i + 1]),\\n \\\"Array has not been sorted correctly according to `ordering`.\\\",\\n );\\n }\\n check_shuffle::check_shuffle(self, sorted);\\n }\\n sorted\\n }\\n }\\n}\\n\\nimpl<let N: u32> [u8; N] {\\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\\n /// the given array is interpreted as-is as a string.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let hi = [104, 105].as_str_unchecked();\\n /// assert_eq(hi, \\\"hi\\\");\\n /// }\\n /// ```\\n #[builtin(array_as_str_unchecked)]\\n pub fn as_str_unchecked(self) -> str<N> {}\\n}\\n\\nimpl<let N: u32> From<str<N>> for [u8; N] {\\n /// Returns an array of the string bytes.\\n fn from(s: str<N>) -> Self {\\n s.as_bytes()\\n }\\n}\\n\\nmod test {\\n #[test]\\n fn map_empty() {\\n assert_eq([].map(|x| x + 1), []);\\n }\\n\\n #[test]\\n fn mapi_empty() {\\n assert_eq([].mapi(|i, x| i * x + 1), []);\\n }\\n\\n #[test]\\n fn for_each_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_each(|_x| assert(false));\\n }\\n\\n #[test]\\n fn for_eachi_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_eachi(|_i, _x| assert(false));\\n }\\n\\n #[test]\\n fn map_example() {\\n let a = [1, 2, 3];\\n let b = a.map(|a| a * 2);\\n assert_eq(b, [2, 4, 6]);\\n }\\n\\n #[test]\\n fn mapi_example() {\\n let a = [1, 2, 3];\\n let b = a.mapi(|i, a| i + a * 2);\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn for_each_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n let mut i = 0;\\n let i_ref = &mut i;\\n a.for_each(|x| {\\n b_ref[*i_ref] = x * 2;\\n *i_ref += 1;\\n });\\n assert_eq(b, [2, 4, 6]);\\n assert_eq(i, 3);\\n }\\n\\n #[test]\\n fn for_eachi_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn concat() {\\n let arr1 = [1, 2, 3, 4];\\n let arr2 = [6, 7, 8, 9, 10, 11];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n }\\n\\n #[test]\\n fn concat_zero_length_with_something() {\\n let arr1 = [];\\n let arr2 = [1];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_something_with_zero_length() {\\n let arr1 = [1];\\n let arr2 = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_zero_lengths() {\\n let arr1: [Field; 0] = [];\\n let arr2: [Field; 0] = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, []);\\n }\\n}\\n\",\ndiff --git a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_0.snap\nindex 3de95a45dbe..5b24d78540c 100644\n--- a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_0.snap\n+++ b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_0.snap\n@@ -223,8 +223,8 @@ expression: artifact\n }\n }\n },\n- \"bytecode\": \"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\",\n- \"debug_symbols\": \"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\",\n+ \"bytecode\": \"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\",\n+ \"debug_symbols\": \"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\",\n \"file_map\": {\n \"3\": {\n \"source\": \"use crate::cmp::{Eq, Ord};\\nuse crate::convert::From;\\nuse crate::runtime::is_unconstrained;\\n\\nmod check_shuffle;\\nmod quicksort;\\n\\nimpl<T, let N: u32> [T; N] {\\n /// Returns the length of this array.\\n ///\\n /// ```noir\\n /// fn len(self) -> Field\\n /// ```\\n ///\\n /// example\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let array = [42, 42];\\n /// assert(array.len() == 2);\\n /// }\\n /// ```\\n #[builtin(array_len)]\\n pub fn len(self) -> u32 {}\\n\\n /// Returns this array as a slice.\\n ///\\n /// ```noir\\n /// let array = [1, 2];\\n /// let slice = array.as_slice();\\n /// assert_eq(slice, &[1, 2]);\\n /// ```\\n #[builtin(as_slice)]\\n pub fn as_slice(self) -> [T] {}\\n\\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.map(|a| a * 2);\\n /// assert_eq(b, [2, 4, 6]);\\n /// ```\\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array along with its index,\\n /// returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.mapi(|i, a| i + a * 2);\\n /// assert_eq(b, [2, 5, 8]);\\n /// ```\\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(i, self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// let mut i = 0;\\n /// a.for_each(|x| {\\n /// b[i] = x;\\n /// i += 1;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\\n for i in 0..self.len() {\\n f(self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of this array along with its index.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// a.for_eachi(|i, x| {\\n /// b[i] = x;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\\n for i in 0..self.len() {\\n f(i, self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of the array, returning the final accumulated value. The first\\n /// parameter is the initial value.\\n ///\\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\\n ///\\n /// ```rust\\n /// let a1 = [1];\\n /// let a2 = [1, 2];\\n /// let a3 = [1, 2, 3];\\n ///\\n /// let f = |a, b| a - b;\\n /// a1.fold(10, f); //=> f(10, 1)\\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\\n ///\\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\\n /// ```\\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\\n for elem in self {\\n accumulator = f(accumulator, elem);\\n }\\n accumulator\\n }\\n\\n /// Same as fold, but uses the first element as the starting element.\\n ///\\n /// Requires the input array to be non-empty.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [1, 2, 3, 4];\\n /// let reduced = arr.reduce(|a, b| a + b);\\n /// assert(reduced == 10);\\n /// }\\n /// ```\\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\\n let mut accumulator = self[0];\\n for i in 1..self.len() {\\n accumulator = f(accumulator, self[i]);\\n }\\n accumulator\\n }\\n\\n /// Returns true if all the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 2];\\n /// let all = arr.all(|a| a == 2);\\n /// assert(all);\\n /// }\\n /// ```\\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = true;\\n for elem in self {\\n ret &= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Returns true if any of the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 5];\\n /// let any = arr.any(|a| a == 5);\\n /// assert(any);\\n /// }\\n /// ```\\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = false;\\n for elem in self {\\n ret |= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Concatenates this array with another array.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr1 = [1, 2, 3, 4];\\n /// let arr2 = [6, 7, 8, 9, 10, 11];\\n /// let concatenated_arr = arr1.concat(arr2);\\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n /// }\\n /// ```\\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\\n let mut result = [crate::mem::zeroed(); N + M];\\n for i in 0..N {\\n result[i] = self[i];\\n }\\n for i in 0..M {\\n result[i + N] = array2[i];\\n }\\n result\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Ord + Eq,\\n{\\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\\n /// sort any type, you should use the `sort_via` function.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32];\\n /// let sorted = arr.sort();\\n /// assert(sorted == [32, 42]);\\n /// }\\n /// ```\\n pub fn sort(self) -> Self {\\n self.sort_via(|a, b| a <= b)\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Eq,\\n{\\n /// Returns a new sorted array by sorting it with a custom comparison function.\\n /// The original array remains untouched.\\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\\n ///\\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32]\\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\\n /// assert(sorted_ascending == [32, 42]); // verifies\\n ///\\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\\n /// assert(sorted_descending == [32, 42]); // does not verify\\n /// }\\n /// ```\\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\\n // Safety: `sorted` array is checked to be:\\n // a. a permutation of `input`'s elements\\n // b. satisfying the predicate `ordering`\\n unsafe {\\n let sorted = quicksort::quicksort(self, ordering);\\n\\n if !is_unconstrained() {\\n for i in 0..N - 1 {\\n assert(\\n ordering(sorted[i], sorted[i + 1]),\\n \\\"Array has not been sorted correctly according to `ordering`.\\\",\\n );\\n }\\n check_shuffle::check_shuffle(self, sorted);\\n }\\n sorted\\n }\\n }\\n}\\n\\nimpl<let N: u32> [u8; N] {\\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\\n /// the given array is interpreted as-is as a string.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let hi = [104, 105].as_str_unchecked();\\n /// assert_eq(hi, \\\"hi\\\");\\n /// }\\n /// ```\\n #[builtin(array_as_str_unchecked)]\\n pub fn as_str_unchecked(self) -> str<N> {}\\n}\\n\\nimpl<let N: u32> From<str<N>> for [u8; N] {\\n /// Returns an array of the string bytes.\\n fn from(s: str<N>) -> Self {\\n s.as_bytes()\\n }\\n}\\n\\nmod test {\\n #[test]\\n fn map_empty() {\\n assert_eq([].map(|x| x + 1), []);\\n }\\n\\n #[test]\\n fn mapi_empty() {\\n assert_eq([].mapi(|i, x| i * x + 1), []);\\n }\\n\\n #[test]\\n fn for_each_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_each(|_x| assert(false));\\n }\\n\\n #[test]\\n fn for_eachi_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_eachi(|_i, _x| assert(false));\\n }\\n\\n #[test]\\n fn map_example() {\\n let a = [1, 2, 3];\\n let b = a.map(|a| a * 2);\\n assert_eq(b, [2, 4, 6]);\\n }\\n\\n #[test]\\n fn mapi_example() {\\n let a = [1, 2, 3];\\n let b = a.mapi(|i, a| i + a * 2);\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn for_each_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n let mut i = 0;\\n let i_ref = &mut i;\\n a.for_each(|x| {\\n b_ref[*i_ref] = x * 2;\\n *i_ref += 1;\\n });\\n assert_eq(b, [2, 4, 6]);\\n assert_eq(i, 3);\\n }\\n\\n #[test]\\n fn for_eachi_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn concat() {\\n let arr1 = [1, 2, 3, 4];\\n let arr2 = [6, 7, 8, 9, 10, 11];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n }\\n\\n #[test]\\n fn concat_zero_length_with_something() {\\n let arr1 = [];\\n let arr2 = [1];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_something_with_zero_length() {\\n let arr1 = [1];\\n let arr2 = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_zero_lengths() {\\n let arr1: [Field; 0] = [];\\n let arr2: [Field; 0] = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, []);\\n }\\n}\\n\",\ndiff --git a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_9223372036854775807.snap\nindex 21f62e633f4..7446892bd24 100644\n--- a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_9223372036854775807.snap\n+++ b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_false_inliner_9223372036854775807.snap\n@@ -219,8 +219,8 @@ expression: artifact\n }\n }\n },\n- \"bytecode\": \"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\",\n- \"debug_symbols\": \"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\",\n+ \"bytecode\": \"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\",\n+ \"debug_symbols\": \"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\",\n \"file_map\": {\n \"3\": {\n \"source\": \"use crate::cmp::{Eq, Ord};\\nuse crate::convert::From;\\nuse crate::runtime::is_unconstrained;\\n\\nmod check_shuffle;\\nmod quicksort;\\n\\nimpl<T, let N: u32> [T; N] {\\n /// Returns the length of this array.\\n ///\\n /// ```noir\\n /// fn len(self) -> Field\\n /// ```\\n ///\\n /// example\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let array = [42, 42];\\n /// assert(array.len() == 2);\\n /// }\\n /// ```\\n #[builtin(array_len)]\\n pub fn len(self) -> u32 {}\\n\\n /// Returns this array as a slice.\\n ///\\n /// ```noir\\n /// let array = [1, 2];\\n /// let slice = array.as_slice();\\n /// assert_eq(slice, &[1, 2]);\\n /// ```\\n #[builtin(as_slice)]\\n pub fn as_slice(self) -> [T] {}\\n\\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.map(|a| a * 2);\\n /// assert_eq(b, [2, 4, 6]);\\n /// ```\\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array along with its index,\\n /// returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.mapi(|i, a| i + a * 2);\\n /// assert_eq(b, [2, 5, 8]);\\n /// ```\\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(i, self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// let mut i = 0;\\n /// a.for_each(|x| {\\n /// b[i] = x;\\n /// i += 1;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\\n for i in 0..self.len() {\\n f(self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of this array along with its index.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// a.for_eachi(|i, x| {\\n /// b[i] = x;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\\n for i in 0..self.len() {\\n f(i, self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of the array, returning the final accumulated value. The first\\n /// parameter is the initial value.\\n ///\\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\\n ///\\n /// ```rust\\n /// let a1 = [1];\\n /// let a2 = [1, 2];\\n /// let a3 = [1, 2, 3];\\n ///\\n /// let f = |a, b| a - b;\\n /// a1.fold(10, f); //=> f(10, 1)\\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\\n ///\\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\\n /// ```\\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\\n for elem in self {\\n accumulator = f(accumulator, elem);\\n }\\n accumulator\\n }\\n\\n /// Same as fold, but uses the first element as the starting element.\\n ///\\n /// Requires the input array to be non-empty.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [1, 2, 3, 4];\\n /// let reduced = arr.reduce(|a, b| a + b);\\n /// assert(reduced == 10);\\n /// }\\n /// ```\\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\\n let mut accumulator = self[0];\\n for i in 1..self.len() {\\n accumulator = f(accumulator, self[i]);\\n }\\n accumulator\\n }\\n\\n /// Returns true if all the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 2];\\n /// let all = arr.all(|a| a == 2);\\n /// assert(all);\\n /// }\\n /// ```\\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = true;\\n for elem in self {\\n ret &= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Returns true if any of the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 5];\\n /// let any = arr.any(|a| a == 5);\\n /// assert(any);\\n /// }\\n /// ```\\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = false;\\n for elem in self {\\n ret |= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Concatenates this array with another array.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr1 = [1, 2, 3, 4];\\n /// let arr2 = [6, 7, 8, 9, 10, 11];\\n /// let concatenated_arr = arr1.concat(arr2);\\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n /// }\\n /// ```\\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\\n let mut result = [crate::mem::zeroed(); N + M];\\n for i in 0..N {\\n result[i] = self[i];\\n }\\n for i in 0..M {\\n result[i + N] = array2[i];\\n }\\n result\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Ord + Eq,\\n{\\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\\n /// sort any type, you should use the `sort_via` function.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32];\\n /// let sorted = arr.sort();\\n /// assert(sorted == [32, 42]);\\n /// }\\n /// ```\\n pub fn sort(self) -> Self {\\n self.sort_via(|a, b| a <= b)\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Eq,\\n{\\n /// Returns a new sorted array by sorting it with a custom comparison function.\\n /// The original array remains untouched.\\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\\n ///\\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32]\\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\\n /// assert(sorted_ascending == [32, 42]); // verifies\\n ///\\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\\n /// assert(sorted_descending == [32, 42]); // does not verify\\n /// }\\n /// ```\\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\\n // Safety: `sorted` array is checked to be:\\n // a. a permutation of `input`'s elements\\n // b. satisfying the predicate `ordering`\\n unsafe {\\n let sorted = quicksort::quicksort(self, ordering);\\n\\n if !is_unconstrained() {\\n for i in 0..N - 1 {\\n assert(\\n ordering(sorted[i], sorted[i + 1]),\\n \\\"Array has not been sorted correctly according to `ordering`.\\\",\\n );\\n }\\n check_shuffle::check_shuffle(self, sorted);\\n }\\n sorted\\n }\\n }\\n}\\n\\nimpl<let N: u32> [u8; N] {\\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\\n /// the given array is interpreted as-is as a string.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let hi = [104, 105].as_str_unchecked();\\n /// assert_eq(hi, \\\"hi\\\");\\n /// }\\n /// ```\\n #[builtin(array_as_str_unchecked)]\\n pub fn as_str_unchecked(self) -> str<N> {}\\n}\\n\\nimpl<let N: u32> From<str<N>> for [u8; N] {\\n /// Returns an array of the string bytes.\\n fn from(s: str<N>) -> Self {\\n s.as_bytes()\\n }\\n}\\n\\nmod test {\\n #[test]\\n fn map_empty() {\\n assert_eq([].map(|x| x + 1), []);\\n }\\n\\n #[test]\\n fn mapi_empty() {\\n assert_eq([].mapi(|i, x| i * x + 1), []);\\n }\\n\\n #[test]\\n fn for_each_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_each(|_x| assert(false));\\n }\\n\\n #[test]\\n fn for_eachi_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_eachi(|_i, _x| assert(false));\\n }\\n\\n #[test]\\n fn map_example() {\\n let a = [1, 2, 3];\\n let b = a.map(|a| a * 2);\\n assert_eq(b, [2, 4, 6]);\\n }\\n\\n #[test]\\n fn mapi_example() {\\n let a = [1, 2, 3];\\n let b = a.mapi(|i, a| i + a * 2);\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn for_each_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n let mut i = 0;\\n let i_ref = &mut i;\\n a.for_each(|x| {\\n b_ref[*i_ref] = x * 2;\\n *i_ref += 1;\\n });\\n assert_eq(b, [2, 4, 6]);\\n assert_eq(i, 3);\\n }\\n\\n #[test]\\n fn for_eachi_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn concat() {\\n let arr1 = [1, 2, 3, 4];\\n let arr2 = [6, 7, 8, 9, 10, 11];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n }\\n\\n #[test]\\n fn concat_zero_length_with_something() {\\n let arr1 = [];\\n let arr2 = [1];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_something_with_zero_length() {\\n let arr1 = [1];\\n let arr2 = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_zero_lengths() {\\n let arr1: [Field; 0] = [];\\n let arr2: [Field; 0] = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, []);\\n }\\n}\\n\",\ndiff --git a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap\nindex 348bf54c6bf..29a13d6cb67 100644\n--- a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap\n+++ b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap\n@@ -231,8 +231,8 @@ expression: artifact\n }\n }\n },\n- \"bytecode\": \"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\",\n- \"debug_symbols\": \"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\",\n+ \"bytecode\": \"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\",\n+ \"debug_symbols\": \"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\",\n \"file_map\": {\n \"3\": {\n \"source\": \"use crate::cmp::{Eq, Ord};\\nuse crate::convert::From;\\nuse crate::runtime::is_unconstrained;\\n\\nmod check_shuffle;\\nmod quicksort;\\n\\nimpl<T, let N: u32> [T; N] {\\n /// Returns the length of this array.\\n ///\\n /// ```noir\\n /// fn len(self) -> Field\\n /// ```\\n ///\\n /// example\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let array = [42, 42];\\n /// assert(array.len() == 2);\\n /// }\\n /// ```\\n #[builtin(array_len)]\\n pub fn len(self) -> u32 {}\\n\\n /// Returns this array as a slice.\\n ///\\n /// ```noir\\n /// let array = [1, 2];\\n /// let slice = array.as_slice();\\n /// assert_eq(slice, &[1, 2]);\\n /// ```\\n #[builtin(as_slice)]\\n pub fn as_slice(self) -> [T] {}\\n\\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.map(|a| a * 2);\\n /// assert_eq(b, [2, 4, 6]);\\n /// ```\\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array along with its index,\\n /// returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.mapi(|i, a| i + a * 2);\\n /// assert_eq(b, [2, 5, 8]);\\n /// ```\\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(i, self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// let mut i = 0;\\n /// a.for_each(|x| {\\n /// b[i] = x;\\n /// i += 1;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\\n for i in 0..self.len() {\\n f(self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of this array along with its index.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// a.for_eachi(|i, x| {\\n /// b[i] = x;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\\n for i in 0..self.len() {\\n f(i, self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of the array, returning the final accumulated value. The first\\n /// parameter is the initial value.\\n ///\\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\\n ///\\n /// ```rust\\n /// let a1 = [1];\\n /// let a2 = [1, 2];\\n /// let a3 = [1, 2, 3];\\n ///\\n /// let f = |a, b| a - b;\\n /// a1.fold(10, f); //=> f(10, 1)\\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\\n ///\\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\\n /// ```\\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\\n for elem in self {\\n accumulator = f(accumulator, elem);\\n }\\n accumulator\\n }\\n\\n /// Same as fold, but uses the first element as the starting element.\\n ///\\n /// Requires the input array to be non-empty.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [1, 2, 3, 4];\\n /// let reduced = arr.reduce(|a, b| a + b);\\n /// assert(reduced == 10);\\n /// }\\n /// ```\\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\\n let mut accumulator = self[0];\\n for i in 1..self.len() {\\n accumulator = f(accumulator, self[i]);\\n }\\n accumulator\\n }\\n\\n /// Returns true if all the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 2];\\n /// let all = arr.all(|a| a == 2);\\n /// assert(all);\\n /// }\\n /// ```\\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = true;\\n for elem in self {\\n ret &= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Returns true if any of the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 5];\\n /// let any = arr.any(|a| a == 5);\\n /// assert(any);\\n /// }\\n /// ```\\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = false;\\n for elem in self {\\n ret |= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Concatenates this array with another array.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr1 = [1, 2, 3, 4];\\n /// let arr2 = [6, 7, 8, 9, 10, 11];\\n /// let concatenated_arr = arr1.concat(arr2);\\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n /// }\\n /// ```\\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\\n let mut result = [crate::mem::zeroed(); N + M];\\n for i in 0..N {\\n result[i] = self[i];\\n }\\n for i in 0..M {\\n result[i + N] = array2[i];\\n }\\n result\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Ord + Eq,\\n{\\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\\n /// sort any type, you should use the `sort_via` function.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32];\\n /// let sorted = arr.sort();\\n /// assert(sorted == [32, 42]);\\n /// }\\n /// ```\\n pub fn sort(self) -> Self {\\n self.sort_via(|a, b| a <= b)\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Eq,\\n{\\n /// Returns a new sorted array by sorting it with a custom comparison function.\\n /// The original array remains untouched.\\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\\n ///\\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32]\\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\\n /// assert(sorted_ascending == [32, 42]); // verifies\\n ///\\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\\n /// assert(sorted_descending == [32, 42]); // does not verify\\n /// }\\n /// ```\\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\\n // Safety: `sorted` array is checked to be:\\n // a. a permutation of `input`'s elements\\n // b. satisfying the predicate `ordering`\\n unsafe {\\n let sorted = quicksort::quicksort(self, ordering);\\n\\n if !is_unconstrained() {\\n for i in 0..N - 1 {\\n assert(\\n ordering(sorted[i], sorted[i + 1]),\\n \\\"Array has not been sorted correctly according to `ordering`.\\\",\\n );\\n }\\n check_shuffle::check_shuffle(self, sorted);\\n }\\n sorted\\n }\\n }\\n}\\n\\nimpl<let N: u32> [u8; N] {\\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\\n /// the given array is interpreted as-is as a string.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let hi = [104, 105].as_str_unchecked();\\n /// assert_eq(hi, \\\"hi\\\");\\n /// }\\n /// ```\\n #[builtin(array_as_str_unchecked)]\\n pub fn as_str_unchecked(self) -> str<N> {}\\n}\\n\\nimpl<let N: u32> From<str<N>> for [u8; N] {\\n /// Returns an array of the string bytes.\\n fn from(s: str<N>) -> Self {\\n s.as_bytes()\\n }\\n}\\n\\nmod test {\\n #[test]\\n fn map_empty() {\\n assert_eq([].map(|x| x + 1), []);\\n }\\n\\n #[test]\\n fn mapi_empty() {\\n assert_eq([].mapi(|i, x| i * x + 1), []);\\n }\\n\\n #[test]\\n fn for_each_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_each(|_x| assert(false));\\n }\\n\\n #[test]\\n fn for_eachi_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_eachi(|_i, _x| assert(false));\\n }\\n\\n #[test]\\n fn map_example() {\\n let a = [1, 2, 3];\\n let b = a.map(|a| a * 2);\\n assert_eq(b, [2, 4, 6]);\\n }\\n\\n #[test]\\n fn mapi_example() {\\n let a = [1, 2, 3];\\n let b = a.mapi(|i, a| i + a * 2);\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn for_each_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n let mut i = 0;\\n let i_ref = &mut i;\\n a.for_each(|x| {\\n b_ref[*i_ref] = x * 2;\\n *i_ref += 1;\\n });\\n assert_eq(b, [2, 4, 6]);\\n assert_eq(i, 3);\\n }\\n\\n #[test]\\n fn for_eachi_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn concat() {\\n let arr1 = [1, 2, 3, 4];\\n let arr2 = [6, 7, 8, 9, 10, 11];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n }\\n\\n #[test]\\n fn concat_zero_length_with_something() {\\n let arr1 = [];\\n let arr2 = [1];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_something_with_zero_length() {\\n let arr1 = [1];\\n let arr2 = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_zero_lengths() {\\n let arr1: [Field; 0] = [];\\n let arr2: [Field; 0] = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, []);\\n }\\n}\\n\",\ndiff --git a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_0.snap\nindex 3de95a45dbe..5b24d78540c 100644\n--- a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_0.snap\n+++ b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_0.snap\n@@ -223,8 +223,8 @@ expression: artifact\n }\n }\n },\n- \"bytecode\": \"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\",\n- \"debug_symbols\": \"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\",\n+ \"bytecode\": \"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\",\n+ \"debug_symbols\": \"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\",\n \"file_map\": {\n \"3\": {\n \"source\": \"use crate::cmp::{Eq, Ord};\\nuse crate::convert::From;\\nuse crate::runtime::is_unconstrained;\\n\\nmod check_shuffle;\\nmod quicksort;\\n\\nimpl<T, let N: u32> [T; N] {\\n /// Returns the length of this array.\\n ///\\n /// ```noir\\n /// fn len(self) -> Field\\n /// ```\\n ///\\n /// example\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let array = [42, 42];\\n /// assert(array.len() == 2);\\n /// }\\n /// ```\\n #[builtin(array_len)]\\n pub fn len(self) -> u32 {}\\n\\n /// Returns this array as a slice.\\n ///\\n /// ```noir\\n /// let array = [1, 2];\\n /// let slice = array.as_slice();\\n /// assert_eq(slice, &[1, 2]);\\n /// ```\\n #[builtin(as_slice)]\\n pub fn as_slice(self) -> [T] {}\\n\\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.map(|a| a * 2);\\n /// assert_eq(b, [2, 4, 6]);\\n /// ```\\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array along with its index,\\n /// returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.mapi(|i, a| i + a * 2);\\n /// assert_eq(b, [2, 5, 8]);\\n /// ```\\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(i, self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// let mut i = 0;\\n /// a.for_each(|x| {\\n /// b[i] = x;\\n /// i += 1;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\\n for i in 0..self.len() {\\n f(self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of this array along with its index.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// a.for_eachi(|i, x| {\\n /// b[i] = x;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\\n for i in 0..self.len() {\\n f(i, self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of the array, returning the final accumulated value. The first\\n /// parameter is the initial value.\\n ///\\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\\n ///\\n /// ```rust\\n /// let a1 = [1];\\n /// let a2 = [1, 2];\\n /// let a3 = [1, 2, 3];\\n ///\\n /// let f = |a, b| a - b;\\n /// a1.fold(10, f); //=> f(10, 1)\\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\\n ///\\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\\n /// ```\\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\\n for elem in self {\\n accumulator = f(accumulator, elem);\\n }\\n accumulator\\n }\\n\\n /// Same as fold, but uses the first element as the starting element.\\n ///\\n /// Requires the input array to be non-empty.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [1, 2, 3, 4];\\n /// let reduced = arr.reduce(|a, b| a + b);\\n /// assert(reduced == 10);\\n /// }\\n /// ```\\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\\n let mut accumulator = self[0];\\n for i in 1..self.len() {\\n accumulator = f(accumulator, self[i]);\\n }\\n accumulator\\n }\\n\\n /// Returns true if all the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 2];\\n /// let all = arr.all(|a| a == 2);\\n /// assert(all);\\n /// }\\n /// ```\\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = true;\\n for elem in self {\\n ret &= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Returns true if any of the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 5];\\n /// let any = arr.any(|a| a == 5);\\n /// assert(any);\\n /// }\\n /// ```\\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = false;\\n for elem in self {\\n ret |= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Concatenates this array with another array.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr1 = [1, 2, 3, 4];\\n /// let arr2 = [6, 7, 8, 9, 10, 11];\\n /// let concatenated_arr = arr1.concat(arr2);\\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n /// }\\n /// ```\\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\\n let mut result = [crate::mem::zeroed(); N + M];\\n for i in 0..N {\\n result[i] = self[i];\\n }\\n for i in 0..M {\\n result[i + N] = array2[i];\\n }\\n result\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Ord + Eq,\\n{\\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\\n /// sort any type, you should use the `sort_via` function.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32];\\n /// let sorted = arr.sort();\\n /// assert(sorted == [32, 42]);\\n /// }\\n /// ```\\n pub fn sort(self) -> Self {\\n self.sort_via(|a, b| a <= b)\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Eq,\\n{\\n /// Returns a new sorted array by sorting it with a custom comparison function.\\n /// The original array remains untouched.\\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\\n ///\\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32]\\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\\n /// assert(sorted_ascending == [32, 42]); // verifies\\n ///\\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\\n /// assert(sorted_descending == [32, 42]); // does not verify\\n /// }\\n /// ```\\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\\n // Safety: `sorted` array is checked to be:\\n // a. a permutation of `input`'s elements\\n // b. satisfying the predicate `ordering`\\n unsafe {\\n let sorted = quicksort::quicksort(self, ordering);\\n\\n if !is_unconstrained() {\\n for i in 0..N - 1 {\\n assert(\\n ordering(sorted[i], sorted[i + 1]),\\n \\\"Array has not been sorted correctly according to `ordering`.\\\",\\n );\\n }\\n check_shuffle::check_shuffle(self, sorted);\\n }\\n sorted\\n }\\n }\\n}\\n\\nimpl<let N: u32> [u8; N] {\\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\\n /// the given array is interpreted as-is as a string.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let hi = [104, 105].as_str_unchecked();\\n /// assert_eq(hi, \\\"hi\\\");\\n /// }\\n /// ```\\n #[builtin(array_as_str_unchecked)]\\n pub fn as_str_unchecked(self) -> str<N> {}\\n}\\n\\nimpl<let N: u32> From<str<N>> for [u8; N] {\\n /// Returns an array of the string bytes.\\n fn from(s: str<N>) -> Self {\\n s.as_bytes()\\n }\\n}\\n\\nmod test {\\n #[test]\\n fn map_empty() {\\n assert_eq([].map(|x| x + 1), []);\\n }\\n\\n #[test]\\n fn mapi_empty() {\\n assert_eq([].mapi(|i, x| i * x + 1), []);\\n }\\n\\n #[test]\\n fn for_each_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_each(|_x| assert(false));\\n }\\n\\n #[test]\\n fn for_eachi_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_eachi(|_i, _x| assert(false));\\n }\\n\\n #[test]\\n fn map_example() {\\n let a = [1, 2, 3];\\n let b = a.map(|a| a * 2);\\n assert_eq(b, [2, 4, 6]);\\n }\\n\\n #[test]\\n fn mapi_example() {\\n let a = [1, 2, 3];\\n let b = a.mapi(|i, a| i + a * 2);\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn for_each_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n let mut i = 0;\\n let i_ref = &mut i;\\n a.for_each(|x| {\\n b_ref[*i_ref] = x * 2;\\n *i_ref += 1;\\n });\\n assert_eq(b, [2, 4, 6]);\\n assert_eq(i, 3);\\n }\\n\\n #[test]\\n fn for_eachi_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn concat() {\\n let arr1 = [1, 2, 3, 4];\\n let arr2 = [6, 7, 8, 9, 10, 11];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n }\\n\\n #[test]\\n fn concat_zero_length_with_something() {\\n let arr1 = [];\\n let arr2 = [1];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_something_with_zero_length() {\\n let arr1 = [1];\\n let arr2 = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_zero_lengths() {\\n let arr1: [Field; 0] = [];\\n let arr2: [Field; 0] = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, []);\\n }\\n}\\n\",\ndiff --git a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_9223372036854775807.snap\nindex 21f62e633f4..7446892bd24 100644\n--- a/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_9223372036854775807.snap\n+++ b/tooling/nargo_cli/tests/snapshots/execution_success/uhashmap/execute__tests__force_brillig_true_inliner_9223372036854775807.snap\n@@ -219,8 +219,8 @@ expression: artifact\n }\n }\n },\n- \"bytecode\": \"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\",\n- \"debug_symbols\": \"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\",\n+ \"bytecode\": \"H4sIAAAAAAAA/+29C5hkyVUeeDPr1VVdj+xH9fuR1TOj0YwE1LMfLIbGVIvRSBoJaaSZkYYZuruqpBFICFlgo0U4sVkeRrZgkQEtthcMa4y9fMb2B0YWK9vYfGAexsbG5gNZoBWLbMAYW0Zg/GC50/dU/vnnf0/GrYzIzKqp+L766uaNuOecOBFx4sSJEydq2b109I/+asXzePG/Bv9ns85keTeL/8v9pZWIsJZT0VjbBzTW9wGNY/uAxvF9QOPEPqBxch/QOLUPaDyyD2ic3gc0zuwDGo8moPH5hJN4TnQ+WeTCOBd2uTDJB2s+GPLOljdmzqyjWXmyin/dp9/7P138rkN+RGG/Mk14Y8K/vnzt9rSoX0T616aB7wng350GmAngL08VcN7easPnulg/qGWp2unqduJ63p2jumVQF8M9ngb3Vo3wZVTPjPDPZEn71EqN8Bk9zB97nrMyrTY9Ncobb3XXw/ImWp31yFMuj05DOe5bdSh3BZ4fK57T9sd7ciNhGyyfcOps76Za2W4yvo3BO+Or8fkIlqe8acgbb3XimSl+jwMehGV0TFD5peL3QvF/Er6x7xsC/yTh76BbvGO+TIvy06J8PvedK57zOc/mgs9rteFFbNOrBn8zDfw1g38L4Gfx4C8b/JeloX8X/ucD/PEE8B8p4KfgzcuB9ojwd/WgR9Pwfhf+K9LAXzX4r0wDf93gv6qAH4/3K9sG+zGgPZ5haHW377w6Dfy7Bv81aeDv8ucLWrF5v3bNYL82Ce3ru/3+dUngb+wY/MeTwL+6S//r08DfHbdvSAN/d9w+kQb+hsF/Mg383Tn9qTTwd/v/G9PAv27w35QG/g2D/3Qa+Luy7QvTwN8y+M+kgb8rO59NA39X/nxRAT+LBvva7rx1Oz7sXbl2Jwlfru3Ktbtp4O/q4ltp4O/Kze008Hfl5k4a+Lty880F/CwB7Lekof2OwX8uDfxdmfPW6Ly5vsubL44Pe3eu+pL4sHfnqbf1D3uFX+Rr/9x2dPLBzvZU9i+00dlabCHrtk2irTD/m+gB6xUEC7+3b83mNAl5sddQtYIXCeCvWZ2nBC+wToZ/TvCuVvLfYHGe4ZohWKlspqpuSL/ZnhpUnnlQBmuqIqxpkZeiTSedeiP+OYdWrkee0JbVD0/y9MiIwrI6Gm+Ql1X6u8KDsB4lPFMR8WB7WrsbniMR8SAss0OazJwWNFj/n4G8mDZLa3/bMzUbOePEfVIsj89ZQTe++4rif17vczQ/4d7lmHjHvJsQ9ExnSeXinTlRR0uWNwu4JylvDvJYhsxDHs8ZC1QfzGtAHju+YRqj38inHN/FB9twuZylhaybv5OUNy3qaHnYT45QHvKN2xP5lqK/G++xvyNOo62edbeVPWdZu7/bu28q/qv+jr4MY+Id9/dpQQ/DQvqxj5qsnKDy3wz0/eJD955VW3F7IP5BtQfiPAo8qtIe3wb15fZAfikeeu1h5ZR86HeOQFg8t85HxIOwTB+wvoDyh/sCyp8UfeFYAQ/7AuJcgPpgeXzO0wS9+97iv+oLC/DdmHjn9QUrNye+qxHvjqXh3UZIH0D8M5meZ27GoWeF27IXX413xwWtDcrLE+uvxwWe4wLPfoJltgLjDfJyr2Of+RwD1omIsE5GhLUoYNk4PAXvY9ogQseh4Z8hWlONw1NED/OHeXda0NoQeVg3zEM8pwWehsjjsRMDluWh3F2k71DmLFAe9u1HCSb2VZ6n65Bn67xcb/4ZwJX/2RprItM+aputdj6W/9SL2jB/rni3QGWw3krnPk55qP+eoDycJwzGoPQBa69QfQDHEvbxCXr3i8X/GPrArKAnRB9INO6D9QHDPyh9YFHwVa2BBiGny2SMaud8HM1n3W2G9BkstLubv5CSQzZOq8ghHKdKDqH/FvNW1Y/3AFB2zNJ3c4J2axe1ZpsTuBV8gzEKdgHjTahdAMcL8nWC3v2n4n8qu0Cveed3M41TzTu1rG3vYfvB72dtmDcKQXKQ2+1/Fv8HZc+pZ7o9WC6mnnMVPxuCHubXkVpnvY4Df5SMqBMf1Nr/uIP3GOHN2+mXH+qEqeZyxMttYfWcLCm/QDRY+Vmg4aNEw6zgA9KFfqtlNM9UpHkmgOZjDs0Nh2aUEdx22IcbTnmW/wz/WKZ5gjJrVsDnPnka6vixkr5Rz/QYtvk7sf1mjXmeZd17Ioonyr6idGMloxmWwq10BePFicS8ON6DFyeI/hOiPMqOBvHimAOrFy9eQbw4mZgXJ3rw4iTRf1KUP+Hw4rgDqxcvNlsHixcLAlY9Kx9biAvlSSa+Qb0Ly39GIaNy+b1W64TL37AMwjwrexXgrQrYLIOzTNsfeM9dzZuoX6o9DFuT8L4D9julT+J8YfDUnuM88cC++2Mg93+tkPtqvzj/u1n8Xu4rrd9Q+/Xx4F+9M038iAv/2g3e0zYcyLs0uvzaSo3wZZm2WRj+mSyTesTNKPS0bRZqHav0fLWvz2t1zOM+OC/wzAs8av+O/bv7gXU3IqwnIsK6ExHWVkRYMev4hoiwHosI6y0RYe1EhPV4RFhPR4S1HRFWzP71XERYMfvX6yPCisn7rYiwYvLrqYiwno0IaysirFGVXy8E3o+qnHgyIqyYvI+pm8Tk11ZEWG+MCCvmnBaTXzF135i6yRdGhDWKvM+fec08CnXMn49GpMtiGBi83RhCxW/0556mPCv7/9Tu/Z8WtEZcj6+H+C80EuGuET7jNb5D/Mo33uieEXn9xGXZ2lhfWd+5sXFna2dte+vaTo3gG638rmyvC8t7vhDH0/B6WcW/OgZ8zdM45DUobwLyjEaMf5V272RtOYT/iL8hyvP+W2hbNjLdt2LBmt4jrONZ5xhAOaHOaPK5jWlRn1E5m8FnkeZFHfPEZwH+SSE4YpxFUnJ6jvIsH3k3nYZ3wf5ehn9G1COF7VTxdVzwVdlOp4nn2LbsK9rPnDyqsNj/G3lZK/lvePhdGZ9jwFqICKsREZbyl087l4b7fxv+mSzl3Ngeh2ov/ZjDuxOCVuWLiHXDPMRzQuBpiDweOzFgKd8r1gNQ5oxTnvJ/UPrDrSKvlx/eb9XauBBfqP+3lf9F8P/+jwVMNa9bvZWPN+sD2AfZbwTHy27MzUz3h5vF7+U+k/HI9uBRH1D9s07l8Rl5aO9+39EHqp7bmRP0eGdtEvtKBOsDhn8mSyoXV7gtka9zgq+J/eN3/b/VuRjVzuj/jW2mfME9/2+lV3t+ESyHlPxCOcT+39M96mcyzZMdSgdnvVH54ah9cwXfYKi1B581V+fpLW9e4LZ+lOhcQ9faE2WUWnvVqTy3H/tnnig6oJJRVXVLJft7zVen65040V7F8xW2HdusztXbML+ueFZtyu2Nbcrtrfi7388oX3Hau+qZpHlBT03Qp9pxMLYnn58hft8vpf55EvijxiHb4E4IvCcdvCcIr/I3V3Y9xMttgT5wqvwxosHKLwMNHy3xa0Y+IF1s71I0j1ekeTyA5g2H5uMOzSwnsC2wDx93yvMcwPDZBxjroPoS2+6t/P8CdWR/8zlBM45h9jcfho/1vMOTXj7WVr8QH2uFG3WGR4kXiXTBNZYdZbxYJPrVWUaUHXy+9oQDq5dezP7mpxPz4lQPXpwm+tU5SjwbeZJ4sejA6sWLzVYnL84k5sXpHrw4Q/SfEeVPO7w4JWAp2za2CfMK5wv8huWwlX8d6GNP1DvhztM3yt7DtvU3Arw3CNgs/7JM2ztszCt/c/sW9dIFUY51yNB9DowbyXzwdAnmxRcJ+a/22IyuvNwnHuqsN+rx48U3iXXbNZ4ns0z39wbxyTsfgu2m9rd4nxH5M+/wZ9zhT6K13prXhz1dSfFT2YvUWp/nTIVbrecP+5vubzzvqhi5Sgep2j8RxnjxzTD5if2tKj/ZTuXZm9guhDI2T49SeeOhrSO4DNsTrPyfARlbe7iTPoxDy2tijPPJ/eSIqLOyV2Adea5B3DzXIG6OhXhEwEy8Z7zMMgXXwGperGfdfQn7Odt83ufYMjAO6ph4x+2m4iszLKQfY8OaPWuCyr8f6Bsv+lDK2LJ5utW69z+k3YftZ8HtHupn8ZcTt7sXlzetT1z4vorhn8m62znFvsp8IF9VfNl54jnOH7wnW9UGuR9gsZ/FC9U3Yq+wvP3NRParYD8Lwz+o/U3PPqZ4d1LQ2hB57GehbCQnBZ6GyOOxEwNW1T3MI5SHfZv9LLCv2vzZa9/qx8nuYPhC/Sys/N8HP4ufJD0QZTr7Uqj4sGq/q0F52D85htJ+9bP4F44+UNXPYlrQc+hnsZtcPwvlz3pQ/SxQDrGsQTnEMgrXxrw+RDnUr58Fyg7Pz4L1xlA/CwXfYHh+Fvvdx/s3HFlT1cd7UtDTa9757brGWeYvMU71sPL/CWzoLy0EykFut99L3G41QZ9qD5aLqf2GFD9D9hhqY531Ogb8UTKC/R6Uv9IxB2+D8Cq/B7UGVb5BNapnmd8D70Ptxn8DGtiHYFrwAelivwdv3RxK85EAmmccmhccmlFGcNspHwJVnuU/w2d7sNr3Un6L3CcbUMePlfSNeqbHMPs9DMNGPunwpJeN3NP/GZa335En9ntIpCuusewo48Vxot87S4D1WxD1P16RF5utg8ULtT6uZ+X9CXHhGMrEN2V7JfcV4zKvx4NjnXD5Gx53mGdlHwZ4LxKwvXk7dK/fvkWdStnTTQ9XepLa9zfarE2xDK4nbrWyjrpb+WWQcVMPa5hY3xq822yV0xdydyLCeiXBUvtONmYS2Z7XE+uca14/wjoZ/n73bhDXTNbdb1Ks01XdvHsXPX+VqnqygpV4z3G3TY849Ub8cw6tXI882bjtlyd5emREYVkdvX2wkP6u8CAsls/TEfFge/K9iHMR8SAsW6d7Zwv2+3mRJ2B+6ve8yJSgp5f9402kA0wBnUoH+LxWZz2s/A+A3f0ZmtdD/Sj47KOymSmbPMvCRHvJbqx9dZZJ6YmoP/Oa881OX1A2Q3UOT/nG8Nkq9rO/GYU/GxtqLMaDv35drTUjwt8y+MeSwL+2rNZE8eCvrfBZcMOBbZ9mX2X1aqi+xvsqifbI3H0VdSbdeLcoaG2IPB5D6myBuq9NwVqIBCtPj7fiwbobEdYbI8FS438U+KXkRj90PRaJrjw9HRHWExFhPRMR1lMRYW1FhBWr3+cpZp/4woiwtiPCiilztiLCisn710eEFXM8xqqj0nH6oevVrXiwYrZjTJnzbERYWxFhxeTXWyLCeiHMac9FhPUaguWdIciT2ZL4jMC/LJT6tHaX1eueD23itcz1GuEzfuM7xK98Q43uGZHXTyzTq9fXdq6uXL99e2ft2s7KjnsWWvmEen1JrYuM12nudV3dUOe0FoGveRqHvJOUNwF5RqOKZZrGX251I4T/iF/55PIZq7369+IYrgrL4o+qmCgp7cl5utXqxJPKnmw2fRWPhm2IqePRqDgmXjwatJPgOOUz37/i2BCrnrk4Iujxzkkk9nsO9t3lMwSJ9gbcMwSKr1XOEOQphd//qMHiszzKdll17DOfY8BajAjrVERYpwWsxHE2gs/yGP4ZojXVOPTieCjenRW0NkQe++edFXjOCjwNkcdjJwYsy0O5e5q+Q5mzQHnYt/ksD/ZVnqfL9hSnxtu48j/ln4jfbrba+Vj+fbCnOFPAVHvBVm81r3PsFhVbwPKwfxqMxGNpmfsB6gOI02irZ939E/vEBL07UfBN6QMqTo4aL+ochpULkUNn0/AuWB8w/IOSQ2pMK33A+HMuDT27Z3nOC3pUO+NZHmwzpM9geWd5UA7xWWWUQyyj1B6PkkN8lmehR/34LI+Ks6h0cPYjUH4fys+4LI7jWHaw1x4vdWRNzLVH2byzPK5xlp3lmaJ6WPm18TbMd9G8cxDb7UbidqsJ+lR7sFxMdAbU5WdILNHPo352CvijZESZ7Q3xnnLwLhJedZZHrUERL7eF1bPsLM8JosHKfz7QEHIuBuniszyK5vmKNM8H0PxKh+aTDs0oI7jtsA+fdMqz/Gf4i5nmSVkMO5ZZVv61UMePlfSNeqbHMJ/lSWMr9eN2HnF4omzVyoaiZDTD6uUPxGd5hhG3E3kx6LidarwmXgO5cTuRFynidobyYrN1sHhxQsCqZ+VjC3GhPMnEN6h3Yfm3gl719vFOuPwN9ls+v2hlvwzgvU3AZhmcJ2V/8M414flR0y/VHoatSXjfAfud0ie9u19U7Du+V+ZPgdz/tYfa9Ci+qTNHDO+bi4e0Z5Had1WqPaW055TC76rkc0rq3PyMyEtxV2Wo/7eVV2cHvLsq0+yR6Lsq8WxCnsYhb47yJiDPaFT7u2l8/teWQ/iP+NW+I+u9VX351X0bMWBN7RGW7RV759ES3VO4u9/unbdE/N55yxrRrmDlyc68eOdZEp/dvG40zfaoN5+vwTaaJVpn09C6nvgcjhvXGevEZ6D2eu4OcQ0qPqQXIyhP3rhGHvQrI7jPpD47POvUu9ecPFtSjzzdasXhSZ4eGVFYVkfjDfKySn9XeBAW68sp/HWw3WPG+WwIWGZDPsg23g8ltvGmnf9W1pR/iCXlVzNLeersFvtjqDkD19CTlIdrcNQJOI3Rb+RT/v/ig224XM7StMDzQuIv6jGcFH+NT6H8VbrdLOWpeWghy0r1joN8VvmXHHkS46wyw0L61VzEfuq/AvTNUKz4VPMiz78p5sU8VfFjHXYMWp6vQmPQ/uaA9pI9P9ZRi0Gb2o/1ZCBfq5yVzhPruP2cYxlVWOzH+kL1Pd0rrDMCVmL/sWA7MPuPJdr7cf3Hzji8OydobYg8th2eE3jOCTwNkcdjJwYs5SPGfrkoc9iPFfs2+7FiX+V5usyf6MREGxfqTVX9WL8M/FhPFTCVLxrv0al9bOXHeory1Pw7Kn6suHfIY9vzY71c8E3pA8qPRJ1lU36sVs47fzCqfqypY6fsBz9W1c6x/FhRDvH+DsohPsOD6132Y0U5FOLHqnxTDv1YO3kT21Z23ZE1g/Bj/awJjbOqH+vnTLRhtmjeOYjtditxu9UEfao99osf66upnw3Kj/XV0E7D8mN9HdCwX/xYn3RoPih+rM9AHQ/9WMthHfqxhvPi0I+1nTZbB4sXw/Bj/QrQq9490QnX82OdpDwr+x6A95UCNsvgPCn7Q6gfq+mXag8j1I+V9Um0LfG+mefHat99Lch982OdFrDzv5vF7+W+0vqG2rOOB//adeVnFQ/+1bW08XyvXfP8LhLHfwq2iRj+GaI1sjxb8cagisnN8avw24bI4z6u1uMNgUfBOhIR1rFIsPLEcdb6oWs2Il1brXiwYtUxT2+ICOuxiLDeEhHWMxFhxexfLFP7oet1rXiwdiLCejwirKcjwtqOCCvmeHwuIqxXR4QVc2y/PiKsmO24FRFWTH49FRHWsxFhbUWENapzxwuB9zFljsWANXh4x3r+W93nxPer/4dinTYK8V+PJcJdI3zGa3yH+OcEPUb3jMjr53zg6vYfLcxW7+6s7izvrO9cvVYj+EYrv2PbvWezxvKJY+2uq/OBuCefp3HIO0Z5E5BnNKrzgWn2ylfXQ/iP+BuiPO8nhLZlQ+Dh+K/9wJraIywvluxCCewsS36Gbne/zHiE+1ZHRL3rWTdP8bwy37P5SWf/UZ1X9O4NrAl6Et/1t55WprdtwupsMtaJ98n7uR/ScA3qfkhVN6+d0V7FY7fq/W8K1qDOYnr3YiL+OYdWrkeebrXi8CRPj4woLKujFxMhpL8rPCqmf8rzdNjuno/9XvEgLPOZUT6RLDPT6Iq+D4bSB6v6tJwpDMNqTqm6FpgS9ITMx40h8E61ZVXeNR3exZiPvfkprd65sho6/3Es9NTz34lAvqozhWWx0PPnCXjGPMQTGnOcbc79wLobEdYTEWHdiQhrKyKsN0WEFbMdn4oI67GIsN4SEVbM/hWT91sRYcXq9/nz0SwOrDyZHc/mBZZnN4vfy32l1VU178SDv3Zb2YPiwd+4o3z3IsLf8s7BpfWVu7ocOmcb/hmiNdWc7fni5YnnbBWXvkF5eWLZpXy71Lm2hsDD46UfWDORYOWJ57N+YD0TEdYbIsGKzfsTEWHFoitPrMf1A2srIqw7EWFtR4KVP7P/zSjwK3afePWI0hVTTjweEdYXRoT1RCRYMXk/qvIrf56MBCtPMfvXVkRYsWRh/sy6/aHM8el6shUPVkydKZacyNPTEWHF0r/yFEs3idknYsvCkyMKa1TXHTHnx4MuC/N0uBYdng5wuBY9nGv3w1wbux2fi0jXYkS6YuqYozjX5mmnFQ9WzDVyzH6/HRHWKK6383SoAwxP3h/qAMPr94c6wP7vX3kaRR0gJiysY6+4VsenOnFiPIQx8a3du8KxAl4O8RQXC5gqDgHH4UbfJ/ZHR/9vgzEo/zfzEyzzfzPa6lQen5FP9u5iUWHl/6buvPHuF5kU9KSNn7C2pnw3I8Jf9WL1po0htHq1RvisHfAd4p8hWiP3xV1fAC9GUZ7YF+CUoLVBeXli3UvFC1I+Bw2Bh+VzP7BmIsHKE8+z/cB6JiKsN0SCFZv3JyLCikVXnrZb8WDFbMe7EWHF7KtPRYQVk19PRIQVawzlaVTlxFZEWDF5H7N/xaTrTiRYseXXq0eQrvx5LhKsPMUcQzHH9lZEWG+MBGuU5+0jEWEdiwQrT7xuV+slpRfnfnHG63e887m3vyujNE6/LeCeISu7nPQB+u5WqxtejZ7HAE5GcB8Q34UshhNdAOkuhtUFWlUXw38q8WK4RnlIPx6AKjNqvAfomysurFJGDWurtBfCtdvjiFMfpK0u+IE85EAif9Zpj0n4bky84/aoCXrmxHfMu0SBBoKDFxr+may7nVMs7o8E8lUFNDlCPMexxoeh9xp0YpRh2QVPaY1e69tzAjf320RGqeALkdgolehwtWuUUu1WxSgVU/nIEweQGhUl8rGIsJ6MCCsmv7YjwhpFw1ueYrbjqBogYhq4RnGhn6etiLBG1cAVq6/mzzEN9LH4lT8fjUhXzLEda6MlTzH716gaKmMa8WL2iddFpOuFMIaei0RXnixQZi+Hhl8lhwa81CbEocHKf8sDbZgfL14mXt+vJ3Zu2A0Mpi4DV4GIvPU6/zdYnGe4BrWeVnXz7BRox2I7X9VL0xWsxDa6Ne7nqt6If86hleuRp1utODzJ0yMjCsvqaHkqQJvlYVC1SYKpAqENSmak7l+9ggly/+pHZhiuQckMVTdPZmBQSJYZCtZ0RViJg4oGywzDP+fQqsYMy4y98iRPj4woLKtjvwFRFR6ExQEiUwSixHbvd/wqPAiL5WKiIKgD06W8y4eULjW3R74irpksqcx3L1by5lQMUow8KIO1UBHWMIMhI685GLKiVekELBf3ypM8PTKisFgupghomyeWiykC2iq9Zq/jV+FBWCYXVeBcgzGowLnqEmEvcC7ufeG+EF+4+JnF5k6MwLk1QU8v28BnH9E4Q20DVv6dYBv43ALmgqDL5vEFgo1zr2rvScpD3huMxBfq7vYFs8FgX0CcRludyuMz8tDePer0hap7wnVBj+IdHz5BWvnwCQYcnKO8M6KO1h5nIS9Fe5wr4GF7IM4zwCMsj895mqB3r3fao+pBpFOCnjnxXb/yE2HZvLOQddebx8x5yEvRRhcKeNhGiPMc1AfL43OeJujdFzltdI54x++8MWPlFO+4f19IzLuLWTfvLji8uwh59oy8s3dvici7U4Ieb3yibDe5EnKZUqILwoN9oTjoaaK1lBv0VOkAxruLgtZG1t0XWL+9KPBcFHj2EyzzhWK5/u6i3+c6xbcc6fwe5af5vKr5j+XnsOe408CPKnPc1zgyQPU9fOfJTyuneNcg3p1LzLvzgnfnHN7hvGTPyDt7940ReefJQ1w/oO7+549onKi78wFqrIeV/2v3t2F+sxgbSlc/Q7As7/3Ak8bD5d+zbnkQ9fnvTKzPq7VdreS/4eF3PH8ciwjrVERYpyPCUvp2Yjke7LNq+GeI1lT6xVmih/nDvDsnaG1kWo7bM+YhHk+fxDzWCWLAUuPqDH2n7DvKD4P3Q7Gv3iry5oB+SyjLfzjADoPfbrba+Vj+G0CWf5DkN84xVm/LU/LOW9tbHo4XgzEq87rRVnVe/zFHbqvxgu+47y0KeubEdyyHEq3Hg9c5hn8mSyoXV7gtka+Lgq+J19y7F6WqdYdq53yszGfdbYb04frd0itb9/4rOcSyBuUQy1xlV1JyyNYyLF/K6mcybcGhT9nBsdxYptf7SvdR8A2Gkl9st0QaWLdUss360SnCdbP4vdxnMj5bG6CMUuc+6lSe24919n/ryCh1DkWNJdW/rFyv+epjNF8dAzp5vuL5DMv/Gqw3XlNsAITYqbFNub0VfxPbj3bb28YgtjfiNNrqVB6fkU/27rec9q7qQ7oo6KkJ+lQ78jyV2u6h+HlW0MP8+hT1z/PAn7GSuuOzsrecd/CeI7z5v19+qLO82jNAvEyP1XOypDyvwa38HwANHyUaTgk+IF18ybeiuV6R5noAzX/o0HzWoZnlBLYF9uGzTnmeAxg+27OxDqovHaM67pafbtfxY1THY4JmHMOmLyTWrdeY51mmbSJlNn4sr3iu1hQMS+FGneFR4kUiXXCNZUcZLy4Q/RdEeZQdZ4kX5xxY53vw4hXEi0uJeXGxBy8uEf2XRHncozhPvLjgwOrFi81WJy8uJ+bFpR68uEz0XxblLzm8uChgKf8SbBPmFcpe/IblsJW/WMioXH4vTXfCXaRvlL2H/VvuB3hNAZvlX5Zpewf7NuE8aN+iXqp8T1iH9OzRuCbmgEDKNqN0CbbNPCzkv8Eea7W/N7rycp94qLPeuG4bL75JvJbZ7e9qXYFrsjJdEsurtVgvHwnmT8PhT93hT6J9hDWvD5eNvzJ+emt9b/4NXc9X7W9Yp/Him2H2N+RP1f5WZsNV825dwEIee/w0Gg/6+C3zAckT25vYLmT/LT1K5VGmj4kyPN9Y+VeCjK093Ekf+19jHvq3cj+ZE3VW9gqca6r4OeJcw36Oew0UjecYBuWve6vVSQPym+23ifzVl1ke4vpd+aTXs+5xgGOU5/BnoX+xHUb5yM87vKsLehTv+AxUIp+j4EDfzLvQ2GZvjsi7KUEPw0L6sS/zGS6UQ9bXE583C96H4XN/Y2nocc/9IX/K/AXwW7Yr5+mFFHvL+r31w6+Edc83T3d+j/KT/c0OovxsDUF+jhHv9qv8/IaIvBsT9KjzlLjn895pjRPXwSgva1QPK/+j97Vhvk+MDaUz8Roc41dmVD5Ppotw/Mr3Aw9PFPrhNJWJ3C/WR/Xs8l79xhDXTNbdVinmJVU3pN/TDzguqYI1VRFW4hgGa9zPVb0R/5xDK9cjTzY++uVJnh4ZUVhWx9Tnt9k2meLcO7Z7ynPveTKZb3JYrX8Tn1XfnUtN58C5FHHOQX2wPD7naYLe/T1nLq0aN0XNU9NZt4y6GYc3G9OCpkiw76TVL1c2lE+7JRUXlWMwoC8Fyz7cU+S5DvciPZ9W7Oucxug38invRxcfbMPlcpaYv3m6Wfxf7i+tsn4bEfZW2nPWo9EvOIYB9gvU3zmpfoE24Cr94iDzl+2Q6jxqKv4qnzK2tS6KOh5kn7KPO3NgDJ+yXj6EnwhYT6I+w341Vv5LYD35G7SGVLHJlG2d2xv1LrbXqxhBacdveBwKo035CXhxKD7p9IWqMaHUmpNhld07Yf4sE1T+94G+U8W6PXWcqVute/9D2n3YZ9S43UPPqNWKoKup2j3mWmU/nivbKyzvbEgi37/gM2qGf1BnQzzfQsU7FVeiIfJwjYN5iOe8wNMQeWy3iAGL1+ZYb+XDMEZ52Lf5jJqKE9Jrvr4w08aF+ELPqFn5x2C+vlzAVHvhPO8q3w+lu/HZc+WHut/PqL3YkdtVz6gpn6PDM2q7yT2jpvYGD+oZNd6/wDyUQyyjcK3C99yoeBue/uGdUVOyQ+nIvIeu9q7UPrCCb+8P8trgcwekI5bNO7dmNM6ydeI81cPKPzLThvlnad45iO32WOJ2qwn6VHvwvJH6zKXip+efbeWfpH52Bvjj7W/bszrrecbBe5rwqjNjymcT8TI9Vs+yM2Psw2/lnwYa+PzVtOAD0sVnxhTNYxVpHgug+bZD8ymHZpQR3Hbq/JUqz/Kf4Z/ONE/KfCVYZln5N0MdP1bSN+qZHsN8ZiyRnXKNeZ5l2v+AeaJiJCk7q5LRDMvzVc4TnxlLpCuusewo4wWfYfXisGD9VDytsxV5sdk6WLxQMTaUHQx5oMZQJr5BXQPLvxt0ia+e6YTL32BbLVCelf0agPceAZvlTp7Umts7J2Xfok6l7J6mhys9CeUy3/OgfLJw7+ZWK+uou5X/epBxZ1/gPlnIr1rJ/yzLgnyyxtLUzfXJQvpfSD5Zalwc+mSV1/Gg+GRZ+X7Hr8KDsGw9zHIrTzeL/8v9pbW0Pl2D80HgNgn18cC5gNMY/UY+VfXxQL/sm8X/5f7StYPiP+K1nee3hX2W06F/TifNmBfqn5Pa/ymmf84Y5Sn7s7Vnoviau7Yo42+ZTYhjD2N74DqI4+X8rGPbqxp7WNktEq8NlxPvIe3qar3i0hj+fv0BENdM1t3vBrUv7rWz2nf0YIXEVEVYifdU3dhEyGvD7+1hhrSpqjfCMp2M5WUMPCo+eYg8G/Y9HizPQu/x+ERiedZrj+k3ZzTOUF9EK3/lvjbM3ybbidpnV3Mb3z1yEOevTw2ovZU8Tzu3bSyHzhcc6zv1fOHJTeRrlVjfeXptq12un7kkT18YEdazEWFtR4T1TERYWxFhPRYRVkzePxkRVsw67kSE9XhEWE9HhPWmiLDeEBFWzHZ8IiKsmLyPSVdMuRqTrlGVhXcjworZV2PS9caIsEZ1ro05HkdVfsVsx5jzUMz5MabMicn710eEFbOOoyqjY/L+LRFhxZSro6pPxNSjXxcR1qjqTDH7/XMRYcUcQ1sRYcVcK4yqvhpTTrw6IqxRndO2I8LaiggrJr+eiggrph69FRHWKM7b+fNMFgdWnmLJifz5aES6Ysqcw3l7ePP2awpYB/nuxO8uOn6quxMZVtmZqVNEn5X/UEFf2v3SjTXbQ8E9z1rWiftiItw1wmf8xneIX90db3TPiLzxPmjduLu9cXX7xs6dtdWrW8sbWzWCb7Tyuzrgz//U3StqL8t4neYumPUdFf//EvA1T+OQd5HyJiDPaDySdfvhpLnXZ30nhP+IvyHK8/mv0LZsCDx8Tq8fWMf2COt41jkGUE6ExINKfSeekt1nBQ+ryu5/5MjuFHcMKtmdp81WJ31W/icGIruXl48D3EzgKuOHOmPlxa7g9iyD9UqCdcqh64IDy2Q3wlLxAJQvKs9dKWMbID6rB75T81Oi+EsrIXzNE/tOqLk0poxKLTtZ3qk7Ygd1nlvJO3XfYlV591FH3lW9B0Dda6XuUKqV/Dc8/I7xqHZQY5nbKNF4Xea+hm2k5s961t3XsE9O0Lt/77RR1RhLi4KetPHbVrZYHmCyPNTtuO/gnYHsb9qEvFdQ3hLkvbXVhs9pjH4jL3KeX4BYe1zOknfPdohfP/Zb9uvnNRLmqbsT0+r77f7eLOBhf0ecRludynO7TdC7/+n0d7XmwXfc388LeqYFPTH5Y/CvpIG/6wO+JHiBdTL8PMYsX/03WJxnuGay7n6XQtdQdfPaeQnoacJzGaylirCmRV6KNm1m5fVG/Er+VWlTVe8m5LGcXYqIB3lodQuRZ4nG0648u6+Ah/LsiqC1TuXxOU8T9O7M7L3/qeRZz5iFs5040S44Rt/iPMVrz09dacO8XMBUc1sz68xDPXWJ8lRMi0HZEMzWW2ZDMNrqVB6fkU/27kGnvVUcEHzH7V12Hyx/VyPepbGdb6yGzheGfybrbucU88W5QL5WiY+aJ/br7yem6RdGhPVsRFjbEWE9ExHWVkRYj0WEFZP3T0aEFbOOOxFhPR4R1tMRYb0pIqw3RIQVsx2fiAgrJu9j0hVTrsaka1Rl4d2IsGL21Zh0vTEirFGda2OOx1GVXzHbMeY8FHN+jClzYvL+9RFhxazjqMromLx/S0RYMeXqqOoTMfXo10WENao6U8x+/1xEWDHH0FZEWDHXCqOqr8aUE6+OCGtU57TtiLC2IsKKya+nIsKKqUdvRYQ1qvP2C8EGE3MMjaosPNQnhqdP8HkD3Bfh/abzkJdiv6lX3LBzUB8sj8954rhh/9rZb6p6VuOUoIdhlZ03uEj0WfnfKehL64e1seH5OaT1idkIvq/L8M8JeozuGZHXz3mD67fXt9dXlrd2bu/cWd/Y2qgRfKOV39UBf/7XFOXVHltaX4mNFXXeoJm1+Zqncci7THkTkGc0qvMGzUT0h/Af8TdEeT5vENqWDYEH/cv6hXVsj7DsvAH6f5icCJHdw/btZNkd6tv5qRGQ3XnabHXSZ+X/O8nuNOe19HmDiyV1QH6cEnVQPinMj4s9YPF5g3MOXZccWCa7EZY6U+Td65v2/FP4eQOenxL5vK+E8DVP7NOh5tKYMkrBOhcRlvUL77zMoM7GKnl3TvCwqrw7UUzCMc4bqPMPqc8b8L1L6uxJ4vG6zH0N2whxXoT6cF/DPjlB7y45bVT1PM0pQU/aMzMrO+rcgCX2m1V9ZwnKmx+l5V2BPD5vcB/kfXGrDZ/TGP1GXlQ9b6DGQMh5A7x7iM8bqLtdUs//iX3y1zz5jHUy/DHuojJcg7qLStUN6R/UGoDHeaJzKGueTEJe85oby/c7NyAslhWXI+JhHuZJ3UfH94A16bubxe/lPpPxfqmAh3NQU9Bap/L4nKcJenfLmYOwT4f0c74/L0+9fOZfPqdxhvrMW/l/fKUN85UFTNVurPshzZcpT8n1UfGZZ70w1Gf+8Yh64aSgx9MLE/vMB8ciYZ/5RHduuz7ziq+HPvPdedsRYR36zFeDdegzXw3Woc98NViHPvPDo+vQZ354dB36zB8M+XXoMz883h/6zA+P94c+89VgHfrMD6/fH/rMV4N16DN/MOa07YiwtiLCOvSZPxjz9gthLXonIqyYMvrQ//5QN+E8z/+e967OQ16KvatU/vcT8/f+x/DhnBT0MCykH/eRpog+K3+5oC+x//1Vb389rU/UxtUa4TN+4zvEr+KOGt0qxmFf/vfr21evbm3vbOwsb6/cuLHbH0Njv1l55ZOh9usS+6+vKv979rEfhzy+C2AC8prFO+V/n+isxmoI/xF/Q5Rn//uqcfwQD/pb9QtrbI+wzP9exexWfmEsu1P7oyrZfU7wsKrsfsCR3VNZN++mBO+U7OY2nRL0jwGszVYnfVb+JQOR3dr/nmPhI70s16fS0HUtVK4b/kH52qm+gfxh34kLgtZG1t0/H2m1y3HemHhXP4QVHZa1GbZxreS/4eF3jEf51PbyQfvc+fY3+J3yQcvTZqudj+X/2pU2zM0CpvJBYz9g5TeXeLzvynt1t5Waf+pUHp+RF/buFY68n4TvxsQ7btMxQc+c+K7fvqPaQd2fxm20X+9Pe4PTRlXvTxsT9ExnKeeIlTvsL4dJzQfcdzyfYqWDKn/jL2m14XMao9/Ii5znH65w/qDqGEjspxp8ls3wz2R6jN2MQ8+K12+VbFG+lvZtQ+QtwDP3uSq2mlrWvd7sB9Yc1Qfr3688RFgvb937f5Dvf/kKRx5WbSN1/0svPeTdpIegnSlED7HyHwA95D2kh+D4O5t1fm95LeDDu17SSbsnaxLpKsGyhtcmqWWNWpt4smZR0Kr6yzQ8Yx7iUfeBKVjzEWE1qD4p9PY8saxR9/uNyjmMRagPlsfnPLGt+P2OrKnaRup+yF6y5jvmNc5QWWPl3wuy5jsdWcM2c8v7K8CHPzl8WbNnO8h+lTWs1/QjH2LKrXpEWDFl4FxEWKMgT3ktm/p+RWVvUPKrqr3hRyLK0zFBTy95+qOR5OmXgzz9BwE2JLZB/Rjw4d2FPLW2TSSj1tPea9g+f+zJQNVWyo6+V/k+KnZuZedEHpTBmqoIK/E8u9umk069Ef+cQ6uSebdacXiSp0dGFJbVMaUtNE+PtjrxDMpev9fxq/AgLJPbie9jvaFsMhnVUfnpKNsUjwO2sWAe2jsWKA/3sFFf4zRGv5FP+dxy8cE2XC5n6YXAX9a7kb+od3I65G8nzZiH/GX7JvK3Ac+cYvB3gWjAOi4IGnhfT+nZKp6QwRgVm4bRVtWmMVkIG6WDYzy5MfGO5XVD0JN6vy2x/XpX51G2ZKwT+4OoWIUh8yDiGlQsQVU3r52VX6gHK3RfxGAl9nld4zGl6o3450T5Km2q6o2weB/zfEQ8yEOOz+fJs2HvB7E8C90PaiaWZ71sCvcvaJxlsZHmqB5W/o+DTeHBAqaa26wfqbntPOUdxPnrMxK3N8NC+rEdFok+K//ygr7EcZSuerIjtW976LzGc6Ta/50ReSn8y0N94VheYXnPvzyRL7/0L78IfM3TOORdoLwJyDMalX95mliWbf9yj/+IX/kisn/5Xv0acdzGgDW3R1jmX+7pQol0wPVR1bXQ1l8r+W+wOI9jxSWycbux4ry9ChWr34N1riKsxGuuNW9+RV4b/jmHVqUP32rF4UmeHhlRWFbHfteLCg/CYjtwijUMtnu/41fhQVimayuftlFbw+zVp+1LHJ226vparQd6rWHeQWsY9DkLWcNY+RfDGuZPOGsYtrMpPVzZ5zjOJu6pNSgP9ywWKW9M1EXRyT6Tw953N9qq7rv/aad/oW11TLwL8bPo1b/+7ILGWda/GlQPK/8rS22YX+f0r0P7bzvx+vl9h/ZfLx3af7ND+++h/Xf/2H+/f8j23x+IZP/9u0ttmD94aP/dTTx//ciI239/fjD237Uh2n+DY/gPw/67cXd74+r2jZ07a6tXt5Y3tmoE32jldyH239OifFr77/rO/rb/ru+E8B/xv9Dtv2pdwrI79TpUyW7P/ztUdv+iI7ur+n83BD0MS8nuPG22Oumz8h8diOzW8UXOldQB+dEQdfDsFtyeZbD4fs9Fh67zDiyT3QgLv2f9GmnguSvRWiD4nCLPT4009KyE8DVP7MOo5tKYMiq17GR5h3SyvEu0n+PKO2Xnqirvfjei3a0h6JkT39VK/hsefsd4VDuoscxttF/jFVpFYsQrbAh6prOU8mPlLssDTFV8dfPEdgl1x7rlNSHvi1pt+JzG6Dfyour9nmoMhNh/VWw0y1M+zuo+W27P/Xqf7aLT36veZ6vuAU98z+Wu/XcpDfxdW2FT8ALrZPh5jFm++m+wOK9ZPM9k3f0uha7RFHXz2rkJ9CAPymA1K8Ia1ftuU9xZmieWs82IeJpQhu/R9OTZEuSlkGfF1nCHPFsStNapPD7naYLefUZiedbL/rvW6MTpnSnGeYrXnl+/1IZ5tYCp5ja+/xT11CblqTX7frf/frbT3lXtvypmCcMqs//uxrum8k8W9CW2/26E2H8T+XRuhM5rPIaQHl5fY15f/r+317fXV5a3dm7v3Fnf2NqoKgusvIoVfEaUTxyfeUXZfzmG9DjksW14AvKMRmX/TeS/vBLCf8TfEOXZ/ltVrqs4zjFgze0RVoj915Pdw45lybI7NJblMyMgu/O02eqkz8pvkexOZdNQ9t/zJXVAfiyKOigdgflxvgcstv+ecui64MAy2Y2w8HveDxwHWDx3JbL5Bdt/Df8M0RqZnl35qOz9yB/P/sv+jansv6ciwmJfBaTT6j0o+6+SF57995TgSZ5Ynvyvjryrav8dF/Sktv/yWD4l8kbF/stzUqj99+sizknjgp7pLKX8GA377+1WGz4nZf81XlS1/6oxELJ/lHq/XPVNz287tG9+R0T5oWzn0+K7m3F4c5V9kCLC3uH1bTzYqytqXLBuksi2HaybGH51N1MK3UTZTdW9OSwb8Ftln2TdpCnwNAUeBetCRFhldgvLV/8ND78rWz/m6eWte/9NhmG/YhnWhLwUMmypgIcyDHFehvpgeXzO0wS9+9uODFP96rLDu4agp5d99ocq2GfztNnqrIeVf/dSG+aPkH0WdUXeB2Od+Wbxe7mvtH5NxX1iOZXGTrB6PVRO8bncRDZn91yuug+Dbaf4redHX6M8xBN6B+SzrXiwtiLCinmHbcx7VGPd5Zk/z2ZxYOUpZjvGvMM2JqxYd7LG5v1WKx6sUe33WxFhxbxbN2b/ejwirK2IsGK2Y0w5EUsW5ilmv49ZxycjwopVx/x5JosDK08x5erRiHTFumc8fz4Rka6YffUtkWAd9onqsJ4rYPHa6sVFYC1bt6CuEHHdctc7q514zXS3RviMf/gO8XsxdGZEXj8+E6srq8sby9t3bm9vr61dvXq7RvCNVn7HPhOqb6j1V1r/lNVrymfiPPA1T+OQd47yJiDPaFQ+E+cT0R/Cf8TfEOUfhTrEakt1HiVtWy6v7e+29GMPqLY03xC0OcwSrbMA62YUOlfX+JxCPNjrK16MqNTx7kLlLsvW1DHkevl3sK1K+U42RB7bwaveEYuwZiPCalB9sA/XSv4bHn7HeBAW29TV2cRRiefUgPowv7x4Tp9d6EvKpt4g3pXJbbVnzW2EPEeb+h8/pnGG2tSt/NuW2jBvFTDVXu9s1vm95T0CfLB76dT3fB4I+zWfB+JzWpi3KGja73dyfYHTl6qeyZ4V9KT2Nx/m/I11Qp2kbK4LnYv2UzxT5EEvPScU1qDimZ516o34vb22kDZV9UZY7HeTOmZniDxLNJ6C/blYnoX6zHxxYnnWa2780mMaZ9l5oHGqh5X/zKU2zHc6c6P1IzW3eTFFDsr89e7E7c2wkH6lO3E7vp9sW2nmwfZ9AEp2pB3T4fcB8ByJ9PCch3kp7gMItWOyvMLy3n0AqeLpK3sIx3wahzy2lUxAnmcPSRQ7bDWE/4hf2ZH5PFA/tnLU9/uFNb5HWGbz8XShVOchRlXXwjVrreS/weI8wzWo2D2qbt6aW91N78EKtbEMaM215s2vyGvDP+fQqvThW604PMnTIyMKy+rY73pR4UFYfB9AijUMtnu/41fhQVima6vYLqO2htlrTKK/5+i0VdfXaj3Qaw3zIVrD9Ippy2sYK395qQ3zw84ahu1sSg9X9rmzVFe8D2CW8vA+gAbljYm6JL6PffnwPvY9p8P72J16I/45Ub5fWYyw2G6V+s7xhay7rnxOYthnRcegPlgen/PEsvIjjszHPh3Sz9UeRi+Z/6vHNM4ymc97Mlb+t5ptmB8nmY/txnsyOB55T8Yba2l8hdrtbbzE9lb7R/Wsm/eot/De12867V1VFineMSykX813E1R+oghSkDZ+YdtuNXjfgHC7Fd8FoOyW6u6OFHar0DPJVl6tUTy7VaJ4RdJuhevDPI1D3inKm4A8o1HZrRLZV1dD+I/4G6I8262qni9X5+9jwBrbIyyzW6lY5d4+fGI9yZXdU4KHVWX30UI2Ktk9Lnin4ngo2c1tOi7ox3l/s9VJn5U/NhDZrePYsB1ArSfSxkRYvhYq1w3/oNYrqm8oPY5tKPitsomwXaqqD9AhrP5heTGNQvqjwqNsJL30+AePt7/B70J9s6z8zzXbMB8uYCo9nmPEKJpT21KsTkrXVfK1nnXPBahfsy68ElHeK94Nqu+o9RS30X5dT32W00ZV11PKljKdpZwjVm4o+7wldRaE+w7uK7JdRt2lo2JbvLnVhs9pjH4jL3Kef7hCHB/P3opj4Gbxf7m/dJf1zXiw168m9JtfZZtWPNjXV0POQiXaPwzWz3gfN/W9mGqtrNY9ajzyuk+N1RrlIZ4QH8k8vao1erB4TukXViMiLN7fSGGjzpN37oDn2NQ2auVrp9boVX3tdpw5tqoOrWz4vXTbt5JuOwl0hui2Vv5Hmm2Yb3N026ms83vLewfw4d3FuYPEOu56Yv0seL/Q8B/uF3bDOij7hYpWJfNuteLwJE+PjCgsq2PqvVT200m9l9rv+FV4EJbJ7YRnVm8nvlur8ppskvLQF4jHmLp3SsVr5XUexnrEuYCTWq8Zn/J56+KDbbhczpLSZXjfdlHUUcULZhuE57c47Pj2Rls9625HXGdzfPvvdvSjqr6Ci4IehqXOUuTJZAnrb99H+wKp/OO8+PajcDeNan/vbprQ9v8Bp/1j3G/grdn3KrMRFs915yPiQVg2P6s7+LgvJIorsdsXTJ5iX1D3hdSzbvmLMXAn6N2HnL5QNW7+oqBH2fZqxLtEcYGD7/8x/OqO9xT6/aVAvnJ8c/y2QXl5Yn2yatza/QDrbQUs1jMMvvpvePhdGZ9jwGpGhLUUEdYVAcvG4X3wPqZNIHQcGv4ZojXVOLyP6GH+MO/uF7Q2RB7bUe8XeO4XeBoij8dODFiWh3L3Cn2HMofPuDUB5qMEE/sqz9PY/mgv+zjZy0zHCbWXWfn/o9mG+etkL0O9yeqtzmbwvYU4FzQpz7unMlHfXea+i/oA4uR7KnFsY7+foHf/0dEHYt5TqWLVJ5ZDwfoAy6HU99wqOaT2DYw/96ehZ93oeUDQo9o598+cz7rbDOkzWLhfavd4KTnE+1Mohy5SXhPyWEYtAT7b87D6netRP5NpSnaco+8uCNqtXdSaXenUCr7BUDKK1x6J9NVlHvfjJfXm82M4XpCvE/TuSBF8Ncb5Me+Mbtm8M3tC4yw7S9CgeuzGrTjRhvma4vkgt9ti4narCfpUe/C8kfque8XPS4Ie5tdl6mdN4M9YSd3x+bLA23TwXia8eTv98kOd5dVcjniZHqvnZEn5i0SDlb8PaPgo0XBO8KHqfapnK9J8NoDmFzs0X3JoRhnBbYd9+JJTnuU/w+d77bEOqi+xzLLynw51/FhJ36hnegzb/J34nqk15nmWaT8B5ol3DxTWz9P/PdxKV0h8P/0ay44yXiwR/UuifBPK8FrosgOrFy9eQbxItAZa8+qGvLhC9F8R5ZccXjQdWL14sdk6WLy4KGApWzOv61ieZOIb1Luw/MtAr3r0RCdc/gb7LZ8VtLKvAngvF7BZBudJ2R94D7wm6EL9Uu1h2JqE9x2w3yl9EnEZPLX/eZ54YN89DvV++oQu80TxPrUfmNp/4/OVNaoH1nG2pI5vGgH6kb9V47lyfJBhnxVnP7zQs+J3nXVCVT+8WUGPF6M58ZmyYFuS4Z8R9UhhS1J8nRV8VWeE7Vslr9gOvddznKMMi/eWkJe1kv+Gh9+V8TkGrBixkWLGcPX24RPbOoL3lgy/ituYYhwqO995h3dqL78h8nhvqapNHvN47MSAxWcPsd485lA2WR72bd5bwr56q8jrZeP7JtLtUGcI2Vuy8l/VbMP8C868zufKlX+M5WEf5Pi4B9HX5NsdfeDQ12RwviYqtvAg7gzP/5qCHtXOuLeEbYb0GSxvb0np1UoOscxVMfOVHOK9pUaP+vHekpIdSgdnvXFM1E/FuVTwDUZMv9lB+0ZaG4T6RqKND9uPbQR/x5FRMX0jy+arH6b5qldcdrbvWvkPwjr/gZP3nlWbcntjm3J7K/7ud1/of+S0d1VfaBVfpyboC9nLSr03qPh5QdDD/Ppp6p9qP+SsgGPPe91D+2lnL0vFr0a8TI/Vs2wvi21nVv7nnH2hs4IPVWOBz1akeTaA5n/l0HzBoZnlBLYF9uELTnmeAxj+xUzzBGWdOn/BffKXnL2sRUEzjmHey0p1PyDzPMu65xDFE7UmUzxXawqGpXCrGMzD3NdDXlTd17tAvPD2TXvpxbyXtZSYF83M58US0b8kyjehTL/7esiLzVYnL4axl4W8SLGvp2zbTYDLvMK9LPyG5bCV/8+gj32K9rJO0TfK3sO29f8K8H5XwGb5l6eqe1m4l/HDzj5Uv/fW1QQfPF2CefGHQv6rOI5GV17uEw911hv1+PHim2HeOYF9qswvKsv8eVL54fI9K8ifUw5/Zh3+DOP+Bk9X6nWHh7fW5zlT4Vbr+cP+pvsbz7uzAlbZPRDPl2m1v/f6J8IYL74ZtTtjQvnJdirP3sR2IZSxeeL7tY2Hto7gMmxPsPJLhQ0h533t4U76OOYE5uGZfu4nY6LOyl5xeA9q+92nQTsM+h457Fdms2K701pBX2o7oPK94D2UYfpUpIptdMNp/0OfitHwqVD3Dan9zVG98ykmrJQ+FfvJD2KvsLy9zES2qmCfCsM/qL1MzxameKf8UtWZM/apUPaQSwJPQ+Tx2IkBS+1lemsYT39knwrsq7eKvF57VLdPtnEhvqo+Fc802zC3HJ3P86ngOV+tYw6yT8XbHH3g0Kfi0KcC6RmETwXKIZZRuA4+RXkohw59KrSM2q8+Fd/gyKhB+FS8l+arvfpUvO9kG+Z/O/Sp2E28H/vtTnsf+lSIeHzUPwflU/Hd0E7D8qn4v4CG/eJT8Tccmg+KT8UPQh0PfSrKYR36VHTLrTJeHPpUtNNmq5MXhz4V1X0qfhL0sZ852Ql3Lz4VPwfwflrAZvmXp358Kt5LOiSWYx0SbVSsQ/I6BmlFXTbEp8LK/4KQ/2pP1uhSe7K4bhsvvhmUz4BaV+CaLMRnQK3FvPMBij8Nhz/jDn8S7U+6PhXYx04RfxQ/PZ8Kb/4NXc9X7W+eD8Aw+ltIbGws753Fxe953lV3uykfAMVPo/Ggj1++lxLLs72J76RDGZsn9qlAma58KjhOgZX/vQg+FdxPxkSdlb2i6nyi7Fp8J9p+jVMwVgCJsac+LuhhWOpOwTyxT4WVny7oS+27onwq+Mwq9g1u/0R+AW77K1t01fZfcNpf+aupvX/V/uxzkuDOwJW09y2N/t0iC/DMaYx+I5+q3i3i+aDxeMQ8tS+73+279zvjpap9N8SPt+z+EJOXSj5kAvetVmd9rPxLSL6Oyn0j3F/2630jK05/qbr/MyvoCfFZSzRnBu9RG/5B+awpvno+a+cFrWpvlv1blM1dxTnZT7DYZy1m7J7UvmF7hXUxIix1J8cgfCF60Yr4Z7JuXSLFOPTs64p3TUFrQ+Sxz1pT4GkKPA2Rx2MnBixlB+K7a1DmsB+JsgepuEM2p/fyAXhqsY0L8VX1WbvZbMN8uoCpdMSQ2IzKd4D3W5Qv8aD0R+Wz5umPoT5r2xH1R2UT8vyDR9VnLZFu5/qsKTvGMH3WVDvH8lnzYo6pOFwsh3CcKjkU4rOmYpsd+qztLRmfU61ZWhHXLHvxWftamq/26rP29YttmJ+k+erQZ6397n0R56QXgs/aB6h/Dspn7QPQTsPyWfvLQMN+8Vn7qw7NB8Vn7a9DHQ991sphHfqsdcutMl4c+qy102arkxeHPmvVfdb+Iehj/2SxE+5efNZ+AuD9YwGb5V+elL0j1Gfta0mHxHLDjgP0s0L+H8ZlOYwDhOUP4wAdxgEaJD8PWhyg/wgyNnUcoE869vUXehyg/+bYK0YhDlCtqORhHKBu/sWIAzRV8DdVHKBDv7L2M6cx+s1zfIhfGfM3TzeL/8v9pfW0/pij0XbTlIdth32Wk2o7PKOxl7Y7iPwt8+moZW3epBobC0SDmu89H/U5UY9B+SgreY84jbaq8n7ZkffIyzHxjuV9XdBTo7wyH/XNVid9Vv4qzfcIN/V8b7imRf1eSHJvHp45qXFpfBqFcTns2CY8LkNjmzwyoHE5J+j3xqWVf4zGZar9WTUuOf4W9g1u/1Tywmt/xMlnR0Lb/3Gn/aueHakLeuYoz/KRd4l8iYN9mQz/TJZS/rZ9mRRf64KvSiZ7NhX2g1T2mXMCz36Cxb7Nymc+pN0RD/M5Bqz95Ced2Kcw2LeZfQoT7WG7PoUXHd5dFrQ2RB77Nqv93ssCT0Pk8diJAUvZTTi+KMoc76wB+zZjX71V5PXyFfuqU21ciC/Ut9nKX2m2Yf7pAqbS+azeSq/jOT/U75l1+P1ql/0GRx+oapedE/SofQ6WQ4l06WB9wPDPZN3tnEIOqX0XpWcPIm5ymVxU7Yy+zWV7j+iDb4l9m5VereQQ77vgepTjCKAcKttrKqsf+zYr2aF0cNYb1R6vWlMp+AZDrT3YTwFp8PaVWEbt172D74m4dzAn6Ok1X30fzVdzQCfPV9h2vLb9G6faME+dvves2pTbG9uU21vxd7/PSX8n4pykzhnUBH2qHXmeSu0rrvh5TtDD/PpR6p/KP3ZRwLHnvfpU/yi00y+X+BVnmeYt02P1LPNtPks0WPl/CDR8tMSHFvmAdLFvs6K5XpHmegDNP+7QfM6hmeUEtgX24XNOeZ4DGP75TPMEZZ3Sg7lP/jTUkX2b5wTNOIbZtzlRfIM15nmW6T0Q5onygVc8V+dPGJbCjToD+zYPw88beVHVz5vXV1X9vJEX7Ns8DD9v5EVKP+9evNhsdfKimZgXl3vwokn0N0X5yw4vLglYdYGHz+ojLJS96pwtnzH5OOhjnzjVCZf9ybDfsm+zlf0NgPfrAjbLvzwpe4fn22zfol4a4ttcdQ+sJvjg6RLMi98R8l/5RuKeXpV4fsOIN4l9qmq8Sau7d+auajzOusOfRGu9Na8Pe7qS4qeyw6kzqDxnKtzqzqDD/pYFxTetC1hKB6naPxHGePHNMPmJ/a0qP3ldieXZ3sR2IZSxeWLfZuNhaDxOK3+8sCH049vM/WRM1FnZK/ajr5PnG4y01bPu9sf+xL7Dl6AdhulTYfox253uL+hLbQdUPhUcXyGR38T6qMmVfverEdegYrB555XyxH1VzTcerMWKsIapy6gzBnNZ73kW63irFYcneXpkRGFZHZV8H/TZhV7xllm+h8bb/eyI8l3tDSnenSTeDduWv1c/4JdF5N1JQY8H66SANVvQmKd3vPO5t78rozROv025s8TKmyF+gL6zgYHwavSsFv/2+wHxXYgSdZLg3yx+L/eZvI6iGqZqR3lNYiXK29wdlFOn4p1qy6q8e9LhnVrc1R3eeZvzk/AdOwLhooKdFsfgO9tYDWmPYTtZc3uEOtneTdwenpMt/zc8/K5szOSJJ3XlkJo6+LTxy4y12EaI8xzUB8vjc57Y+Pt2p42qOqzOCno8J9PEwbKCHZ8M/0zW3c4pFhgXAvmqDpJw8APceGKFVm1KKUfP/QSLHaH3UzDlvcK6HBFWU8BKHCQp2BHa8M8QranG4RLRw/xh3l0RtDZEHh7owjzEc0XgaYg8HjsxYLGzINabxxzKJsvDvs36D/ZVmz97OZZ92+k2rlrmO5blabPVzsfy4802zA+QoVbJe7WOuEh5atPV8pS+PyqLfKOt6iL/rzr6AC4kvcWlcjK0cnPiO5ZDo3bpQ6K1pHvpg+cInWg9sOsIrfQ+1c7oCF0WPBXXFpbYEVo52Sk5dJLy0FmCHaFRDpntQsmCQa99G8APtfY12pTTB27M8ibYDzvjlvs7v/P0eCuneFcnWizvpWfu/c/l8Ido06VGsG8Wv5f7SmvX1CHyePBXV7yNjLR9ZyVYfzL8g9oo8TYMsqxbf5oXtDZE3hF4xjzEMy/wNETes614sB6LCGsnIqzHI8J6OiKs7YiwnogIK2Y7PhkRVsy+eicirFj8yp9nsjiw8hSrT+TPRyPSFZNftUh04dyYeC6+ERL8AGV8xLlyu0b4jE8Z1dfwDyr4wRGih/nDc+WcoJXXVXl6S6tdjvNC9ogQz0QWD9ZMJFh5elMrHqxnIsJ6QyRYsXl/IiKsWHTl6W4rHqytiLDuRIQ1qn31qUiwYveJV7dGk66nI9GVpyciwhrFPpGnrYiw3hgJVsw+EVuuHo8IqxYJVp6ea3XCqglYao1vZUP1nD07IDFhJ0oIuEjf32p1w2XGZfT7RI98tWGYG73+ZWEAU84dfCIJFWHPg9zKjYqhkiOvhRoq1wvexIi8dkTQ4xnq+L/h4XdlBtE8WT9SG0TcRjjIU7SRGcSxjRBnA+qD5fE5TxP07nOcNmoQ7/id10ZWbk58VyPeJdp0Cd4EMvwzWXc7p1ggngzkq/FObfbtJ4/pmLDYKURtLlYd+8znGLBi3kh+NiIszzkrkWNb8KaG4R+Uc5YX1UDx7oKgVW1sslFPOYFdEHgaIo/HTgxYyrvcO43KG67Yt9kpBPuqzZ9zQL8ldAp585k2LtQ9qjqF/PrlNsy3kl6mHBTUvM639OEcyzeGY/80GPvdSfRPOPpAVSfRhqAnRA4dOolqfWCY0fFUO6NTCLZZ1eh4yrlKySGWUeiIcpzyUA7xerLRo34cHQ9lR4O+Oy5ot3bhtsTyCEPBNxgHee3x3gGtPcrmnW8+o3GWRbljJxgr/63gBPPPaN45iO32gcTtVhP0qfbgeSO1I6bipxcZxsp/D/UzdQN1Q8CxZ+UAGnLb5vdAO3G0OrUGRbxMD94wqsqfJBqs/PcBDRz5rSH4gHRxtDpF81xFmucCaP6/HZoXHZpRRnDbYR9edMqz/Gf4HMUD66D6EsssK/93oI4fK+kb9UyPYY5WN4wIBEccnvSKbOLp/wxL4cZ+yNHqhnGDJfJirzeCLoj6n6vIi83WweKFWh/Xs/L+hLhwDGXiG9Q1sPyPgy7xT890wuVvsK3mKc/K/gzA+0kBm+VOntSa24vQZt+iTqXs6aaHKz0J4XH0H8v7+eIb5QAcc75XUV3qUMcUez5jlKecgqze8/TdzeL3cp+J+wLqG8qht+p+0EccvbHqRuYRQU/qqEqJ9yt25ZpaI2Kd+IAN8qlW8t9gcZ7hmsm6+10KW4e3/s0Tt7Nar3iwjleElXgttubJV+Uk4O2XhbSpqjfCsvXvXNbNr37xKFtIiDxLHcBDRUHzAniERkH7VGJ51st+8QcV7OY4T7Hd/O+C3fx/OHZz60eWh3PCccrDsWrl9rvdY6JQFmPYPeYFPd78q/wxeH69XNCXdlxtXPX2S9OuCTeuhs5rHJVO3dIwI/LG+6D1+vr21atb2zsbO8vbKzdudB3gNVr5HdsA1LrmmCifdp21sWp9DqOfcuTeccg7RXkTkGc05mPnNNGf5pDrxmoI/xG/2t9kG1RoW6o9Cj5s2Q+suT3COp51z3GePWTU5mqW3aFz9QMRZbeyWau1Ry0af1a3lI07Hvy1bc9vJe04XVkJlel8a1kiu6N7a5kaU7ynrWQK2p74IM9ebwutZd2Hb/q5efSJiHQdjUjXc5HoytNjkWCpsd4PrMVIsGLWMU+x+mqediLCejwirKcjwtqOCCvWeMyTjSGTVUchj+V8GvtZuJw3/DNZtyxJIefV/H9U8FX547JvHOogPHb6iRDNh1v6gTUTCVae+BBcP7CeiQjrDZFgxeb9iYiwYtGVJw5uMCp94omIsJ6OCGsU+1eeTM4vCNgm00zOoxwY1D7SjKh31X2kr3TWchNZN+8mHN4dFfT0sru+56zGGWp3tfJfC3bXVgFTtRuvwVO3265tJwtrN7RFoI2b7cxfF7Hdjgh6Up+XS7y/uLtXpAJ/KDv8nOBTreS/weI8wzWTdfe7FLqWqpvXzmrf2YMVGiCF94wT7am7N24grw1/v3u6qt4Ii/f/5iPiQR5a3ULkWar9euO97f2U3YLE8gz3inB/dILefVdiedZrHvreSPPQkzAPfZ8zD/GeLs4J85SHY9XK7Xf/lb/ltHfV/d4ZQY83/2I7lN22/k9p/y/NuNpY83wHDPeJRLhD5zXDPyfoYZ8XzOtn/2/j7vbG1e0bO3fWVq9uLW9s1Qi+0crveP9P+TmfFuXT+r2v76j9P/Q9ytM45J2gvAnIMxrV/l+aPaX1nRD+I/6GKM/7f6Ft2RB4eP+vH1gTe4Rl+3/KHyJEdg97rmbZHTpX/1xi2e3pbYn9XoLPNY6qr58no9WY5DPRex1HowzL4hx455DTzrW+P5Vqq6r+VL/mjMmqvp3qLKjiHdvAhu3PwLwL9Wf4rYi8Oyro6bX2+B1ae+D5A7X2mKB6WPmvutSG+UnSX1PZuYa55ldrphh2HMM1KDuOZ8/IU5kNgnmwl/nX008SzWm7bTrj1FvpA1i+SpuqeiMstuOksBdh3ULsOMNe1+91P+FosVE+LDvOwjmNs6od5zUgS48XMNUZJetHITYez84+7H0Io63qPsQ5p71VUEN8x+2txgPDQvqxHdiOY+XXC/rSyrSNDc8GnNiGFLxm4b0Oda5AxW3ry4/79vr2+sry1s7tnTvrG1sbLH+MVn7Hdhylh50R5RPbzFaUHQf1vDyNQ16D8iYgz2hUdpw069uNlRD+I3517ontOFV9fhEP23H6gVXfIyyz4yi7dojsTnRhjCu7VYzTqrL7MxPLbnVpQS0af9avhtiJ0uhR4ZcLsVxNbSfy9rvzxHYiNQeoscVtuNdxmie+sKUfWNsRYT0TEdYbIsJ6LCKsnYiwHo8I6+mIsGL2iSciworZjm+JCOuwTwyvT7CPIcpZtq8O2ybAekaoTeDtEfWMo4KeXjaBd57TOENtArtrSbAJfLljE+C4JagbcdwSvtAJ85Sf4LTgQ4q+YPol9gXEabTVqTw+Iw/t3Vc7fUHZA/Gdp3NauZS2Qmznuay7rv3iQR6yvSuVTdL6n4pDwH0Ox/sw9qvnoT5YHp+zrHu/+n1On6vq96j8DFPHYhhUrBy1x4p14lg5e/V3RFwzWdK5bcWrm9fOak/WgxXqa2KwEu83u/GPkNfs25Uihk2eeI/lREQ8yEP2nfTk2bD3q1mehe5Xf39iedZLn/oB0qeOAp0h+tSuHgH61A86+hT7ICDNJyhPnUEZFf3ZaKuqP/+I0954tnJMvPPam8+VHxX0YzscIfqs/M/THkuifY6rQ/SVDY6VMwxf2bJYOTF8Zb1YOWl8ZXWsnP3jK9uOlTMqvrJsu+0HVn2PsDxf2cRr2vVhxiX0/MHQzlEr+W+wOM9wzWTdbZxCf1Z18+w0OAfwPNPPHh/bxBKtSde8+TXkbjb8Vtn9brXi8CRPj4woLKujFycjpL8rPAiL4yk3IuLB9mR7417Hr8KDsEzXVj63rNPuV3/l33V02qo+txOCnl5rmP9Ka5hePre8hrHyv36xDfO/O2sY9idQeriyCTeorsomrOyHZZffI11qzTRqfoh7XTMdKS7wirFm8vZkUtlEh2kfwjrxemavMhxxDSoWkaqb184HOT62p4emmC/zxDa/VPGxWX568mzY8yXLs9D58kpiedZrvnzReY0z9IyKlf+7MF8+VMBUc6L1IzUnsj3wIM5fK4nbm2GVnY8vs92+oqDv0OZ3aPPbC/3E60ObXxbX5rdXO52CleJ8/KBsfsfSwA/WtQy/yYY6lK+V/DdYnMc2v3qaurk2P6T/hWTzQ14f2vyynnU8KDY/9vfa6/hVeBAW2/xQbg36rluT5WV3vhyD+vBcgfPABL17u6PTHiPelekhSqdlGYs87/ADpTXMXs/ZfwDWMF9Oa5j9YvNT+/qD8i01Ppb5lhptdSqPz1nW3S5f4/QvHGshc9kRQc+0+O5m8X/l+trq6rW1G9eWb1zfWl5Z37q7en11devO+vLd5dt3V7dvrK/c2FlfXV+7u3X3zvX167dXdpZ3bt+9sXP9edas9Oq7X0d9t5cPM/ddK/8a6Lvf6PTdvfowD/pcs1q/eueasZ/hfMLr229x+lKMs3G92vsvUnvv9Rz7/7jQhvkdtGZPpD/u6t6J4mbs6mk2x2aZ1tO8mAG1kv9ZpnVvezeTdfM+he6t6ubpEkgzr/0UrLGKsKZFXoo2rTv1RvxzDq1cjzzdasXhSZ4eiQjr8yPCsjqm1lVZ9x6LiAfLWLl+x6/Co+Su9fFJ+D6FXEzkq7M7hqaIF1wnnoP6iZVkuAYVK0nVzYshMwX0IA/KYE1VhDUt8lK06aRTb8Q/59DK9cgTy8W98iRPj0SE9fkRYbFcRF72K0cQFsvFqYh4sD1Zr9nr+FV4EBbLRZRb/exdUFpNvFa4o2xRGfEQ19Fs8+GYDZiHa1OerxaIX5in/MpqWXcao9/Ip/y797ykDZfLWVL8jdh+64ntBnfVWcuM+KlsHaqNuP2wjbj9sI2mKQ/tc8hXTqr9jE9V229U+DtJechfnoeQvyy3Ro2/05AXkb+31ZnkjOqLbcv8RdnE/FXxBVW7sPzBdqkqf4xPofxdIBpwjCrb0xjlqTXBAv1Gvi3Qb+TbAv0e5Hxqeoiym/E6O1Ff3LWbWV9EuxniZLsZjkHsxxP07mhhb4phN1M2asU71sX3q83xRETeqfUew0L6sS9PEX1W/gzYEl96oRMf9vOXt+799/TgxGvh4JiIhn8m65YLKdavqh3VOsZ4p8Zkg/LyxGuvaYFnWuDZT7AsjruyO6Ht/MUXOnGqvRLsC+OQj+VXoL+/RPR9NQfxvovlLRffJLa9L+M+bUa4joo6roHM+dhDmm/1TNsiX9nqrFMi/dSNF418LPNtxPJKTls7TjuwFG4cy48SL1LHzp7twYs5on9OlEe9kuMYH3Vg9eLFK4gXw4gNj7zgNXqvOwGZF7MOrF682GwdLF4cEbC8eFV1AZPPzbGsycQ301R+WpRXY3uCyr8K5PhHimeeaw2G+p+nEL0fYd1qdeJJFcfebKbq7iHTMQblF2/ry9B743A9ugB1mqB3Tzk6sur7cw7vpgQ9c+K7vbYRr7VjwIrh58Y2lhiwBu+fvxwcg5djTSXyn3NjTR13eHdS0NoQeayTKN/9kwJPQ+SxXh4DlvI74zjiOM6nKA/79qMEE/sqy1N1djqX7++idYDy91NzNfuV/QrMGX+SdH8vZjj2swXKwzHBZ53UnUZpz1+05bbd/YRyG3EabXUqj8/IQ3vXcuR21b7nxaTD71gOnUrDu2Bbg+GfybrbOYUcOiX4quSQ8ed0GnrWjZ4zgh7VzvlYn8+62wzpM1jj8L2tR5Uc4tjmKIf4TI46/6zkkNm5WL6U1c9k2oJD35igj9eSSp9aELgVfIPRS3b+xQqy08pYPpb/DpCd/6IEZr0EJvslJzr34eqsap+WddLvonrZGCtrK+bbMYH3uIP3GOHN83+ZbDeqP6i1W43qOVlSfoFosPLfCzR8lGiYF3xAuvi8W5U+XEbzXADN3+/Q3HBoxn7ObYd9uOGU53HI8I9lmic47pTPAffJv+XY9RYEzSi72K43jDN0kw5P1FkR5DnrWvMOLIUb+yHb9YYRjwN5cYLo7xWzl3XLYw6sXrxgu94w4hEjL04S/UqP9PTs4w6sXrzYbB0sXih9qJ6Vjy3EhfIkE9+g7oDlfwJ0g5++0AmXv8F+e5TyrOw/A3g/JWCzDM6TZ8tnHQm/RR1J2fxMN1RnuI4DjH9B60nEZfDU/sQM8cC++zdQ719w9mhvtdrlPlKyXzZe/OXvZgVdjPsjgPuX+sSdJ7XnVOZ7jt/iHqCaA3h+Pg718XQljiv/cajvHwzYLsDzWOhaz8qfFuVxrcV7Y2gDOB0Aa97BrdaBpx3cSBd+y7iZTvtOxZZAu0qexiEvpm0gr8v1T2/TgTTmaaLVyRvVjlg+hJeqHRtUHnlXdb28SHkh62XsvzheYsvkd9E4RB959g9DGLgXwPJ1DN5nBJf9n+rF+Uqld+OeGMPME+vdie4VDI5tynczqj1nFW9d7QcyLIUb5wjWu4exb+qtl3vtm/L5bm8Pea4HL1jvTh3/opftgOdPT1dW8583F/fixWarkxfDWJuq2AM1+o3lGw4v1Nq/LvAovRv3UDPxDeuIVv4cnAF/1cVOuGxrwjFv+zy99vTLYM07sBZKYNXoXZl/ANt6rPyroK5LxbPnQ+rtnas2GyM6eWxy25lc4/4yCbCwDNfLyr8Y5pnaw50wlc0I564yO+ZLxNyldCd7l5f7BJTjuo4X3wwq7qUae9hWfI+PsrXgeOZYG/g93jfG/Flw+DPh8Ce1z5jyVUL9KMRnDOd0jnWE3/N8r3CXxfN5vkyr/b3RqPiJMMaLb4bpg+f5zYX64Hn6eC3r7kfcNnny+InnY5ifCGO8+GaY/MT+VpWfPH6xPNtnlL+88hPiNkL5j/sRNu947VWDd7y+qYl6YFwQNYd5Ppw8HnvFPiqbu1/vrG+UvzDWkdc3w9BjkSdV9Vi2S3h6rKdD54nXN8OYG1VM6NC5ke1WDQfWsR68GIV9BeRFVVv6MeKFt6/QixebrU5eJPL3WfPqhrxYJPoXRfmTDi9OCFjqXBTfB4iwynz8y/YI3gY6/7fR+objMWNb8ZlEHN8sW3EszFIewuQ56wTQrOQu18nKvytQNze61NyOPB4vvhlmP1N9I7Sf8RyN5fH8GfPnhMOfIw5/UsskTy6EyiQln5UfaZV5L0+eLmk0Vl0Lpt5H77UWDNlHR35yTEYV07+WdfcjtgHlyeOnt3b01jqjEufY47/ypfL8e9XeKe9LoF7rrUdxz/XbSDdX7VWDd55ujnuOFqORdebvdHRm5QOHuFk3Gob/Ccqhqv4nfEbI8z/x7irOE+vMw9ATq8pkdReA0i/Yb5nv1VKyPe3YX1lTeoMldXaB7xLBOb1BebhHyechTgs+WB7uXyL/OI3Rb+RT3oYXH2zD5XL4zH2wqnzAvcl3knwwfv2QIx9QXw1ZU++3McH7ZPMOLG/dlieWD4n8/Xd5sdiDF6eIfm9vH+un/D1OVeQFzxuJfPvXvLohL0J8Rk45vPD8T3rxYrN1sHhxVMCqZ+VjC3GhPMnEN7z+tPI/C2vqj18sp4d9lnA88/yn8CYeu8vMc/S5VzyvZ91thu01Qe9+AWQ5n3OqegfLvKAntM/jnPp8mVb7e+R1nsYhLyKvV3MePEa+Tx28a3XmoS/TZKuTFzjv87ygfKDOCF4oWFV8mVCvtXrgeOAxhvSE6gtHAe6LStYT/y7iemIY+gLuOVbVF3g94dlaFW5vPTEMGxjyoqoNjOeFeQGLy2aCb+MleXUBl9ceafyyVtbVeU5Lan3Baw+U5bz2UL6man3B97qdFTyqZd1JrT2MT8Nae9h9xzyvj11q0zXqaw9lg6oqS1C+V1l7ePavPI3C2gN5UXXt4fman6rIi1FYeyAvqurbzAtv7dGLF5utg8ULb+2hxhbiUmsP75yQlT9fyKhcjq1cKqfHs6/xXKnwjsraowF84jbz1h73gSzntYfqp/jOW3uE7Bcdrj36X3uoc5tqvwnXHjYeeIwhPaH6Aq49foD0BdOTrgp9YVDnFXr5L4acV5ihMnlSvlS8p6/80BLX270vTfkNKn3duy/tpiMvZhzeGa48qb22GYd3fJdnonMdwfdzM+9Q1jUE7+zdIxF5d1TQ48FSMc2qyubZrD123vHO597+rozSJP3mYCdGGG8OmYCxskdKCGyUwC+7nKNG71Eo2rsxUSYrwa/gx9oIficJT2P0a53FVtXDYakdBnsdfAlxGMTBxIfD5h1Y3kIvT6NgxOpn06vfQATegaj9zgu1oFfCmYP08xjKxDe8wLDy27DA+MpL5fTwxOYd8vYWGImcOJaZ5zjpKZ7Xs+42w/aaoHdvG+ICQ13yNcQFxopaYHTwrtWZhwYbXmCggYEDJqJCwIsCVLrwcPVX0qIg1uGDBZrXjNdf7SwKhuGwhDyr6rBkdQ8xIqggXaMyxtmIHzrGv8EZ48cd3hmuPDWyrFRf8ALG8n/Dw+/KAkLmyQ6WKkMmt1HqYJrK0OMF0ww19Hyr00ZVg2mquVvxjhe9iQyZu7w7K3h32uEdbs7YM/LO3n1nRN4p+esFIq3av3njKQascxFhnY8I64KAZX3tIryP2NeCA0gb/hmiNbZOUSN8Rg/zh3l3SdDaEHl8iPSSwHNJ4GmIPA4gHQOWOqxwgb7DcT5Hedi3OYA09tVbRZ4Kqv6yIi/Xd36Y9Ch1eAe/3Wy187H8Z15uw/wgrS9wzmb5i3PFWcpDWXiO8rB/GozEY2mZ+wHKbcRptNWz7v6JfWKC3v2YI7dxbHjjRenbVi5EDl1Kw7vgANKGf1BySI1pFYzK+HM5DT27AaSbgh7VzhhAGtsM6TNYXgBpLzA/yiGWUecgj4NsoRxim+rJHvXjANJKdig9k9ciY6J+yqFAwTcYB1m//uXE+nWveedXLmmcat6pAU5ey/2/YNe6UnT+g9xu/y5xu9UEfao97Nn4ibJiUPw8K+hhfv1n6mfngT9KRrCd7pzAe97Be47wqsDlyiEF8XJbWD0nS8qfJhqs/KeABg4CflLwAemy/QeP5hMVaT4RQPN/c2g+69CMMoLbDvvwWac8y3+Gfy7TPEGZdVLA5z5Zu9yu48dK+kY902OY98jOEc03i9/L/aU15nmW6b0Q5sk5UR55bvVTMpphKdzYD9khMZGuuMayo4wXF4h+pbOj7OD1zjkHVi9e8H5hojXQmlc35MVFot9b7ytenHdg9eLFZutg8eK0gKVsghwomOVJJr5BvQvLn4X1/MXLnXD5G+y3vP9oZZsA74KAzTI4T8r+wPs4at5E/VI5np2HcqwzqiA/ai/EnBn3+17IQzAX9bsXciqQd+wglWg/f5d3i4J3Jx3eoZ7eEcia3q1E5F3VQFWnBCyuL5Y/6pQ/HVi+p0MVR0jlxT9u/GKyycvKokcfD0qsYKOkImWOV0cILn6b0W92ohrLulOvb0NhY16s0zC/U0h5ZUhhRcv4Wbb4RqMwlv9sEOSvv1yOL4XR9zzVIdSQZ+Uvi/JoSGOnHZzELwfAOuHgborylx3cSBd+y7iZTvtOOZGg0TxP45AX0/CrbgdABWii1ckb1Y5YPoSXqh0bVB55V9UYyhtQIcZQ7L84XmpZd3+pqvicALi2ocMOYG90Fp0vNMfMGQdWL8es/R6h59Axs5wXKR0zOVK9lX8bzKFfc7mcHna+VBHDFhy8+90x88sdZbuqY6ZyOAzt855jJvI6T+OQtx8dM9H5h+dRdZIY+zCPi+d5Be8thTpmfi/pszg22PkY2zdFH1cnbmYE3VVP3Pw5p48rPqp+qdoHeYW/yyK0zhF9Vv59IKt+8LIu8y196BlsxByGnuEd2himnjEMJ+Oq0Xm8WzknBCw1X7FhLVEfWOZ6jPeoR13wAXnADlHfHXG+8k6rI+/YsLZf5/rvj8i7qtHwPcOaF0lclQ81xPVtWMPJGRMb1vCopZoYThIcrsh+NKzhZOVNpggvVCl5T6GU8PVTP+RMgnilVchiexghm3BRVTVkk3cVGsNSuPHoL0+CibxMgsManiX61U4kCusQw2coL1g52m87/8yLUw6sXrzYbB0sXswJWGrSRB4oeZKJb3hH1sr/LCjzH79cTg8rHF64S4V3UB5iylNL8byedbcZthfvav+Co4xU9bjzwm/16vMjcCJUhpzp4F2rMw89ZtjwgIZxnheUp815wQsF6xTlKQ8B5RVg9cDxwGMM6QnVF+YA7h8UsXHUOCsLQRa6SLfyvwHjutYsx8cyCPm0SHnK80F5LfGcpjxjlLJu5Xt5xtQIt+clpGB5YUW8jSeFG+nCbxk304mnMZ7H1WrnoVdtnsYhL/WmHI6viVZnvT1PtjyF8FK1ozrBxZtrav5TxsvzlKe8UdRmHo77WrOTxljj/s3OuMe69zPujzTb+C43y/FZO6hxf5HyTgo6lS7LG+JKX/LGfS99iceepzsqWN64V3PNOQc30sWnQ/nkKdJp343auMc1D497b32TpxBeqnZU8/Y5ykN5weMe5TLP9zieeL7Hfmr9F8dL7HH/bYU3gPUd5Bc7sOC4VuOevcmt/IuabXx/rFmOj8O9qTWHkgnnKU+dLPT6izf21BwdOu5D5vu6g7vqfI909ZrvQ8c9RhzI0zjk7adxr3jpjXtvvsewf6zno1zmca9O5ShZguPexkst6+4vVcd9HeB+VUHcgqgTj5le8/0s5GP5zWYb35ua5fhYX686tlX/53Gi2t+b73s53/HYw3YPcb6bdXA3RfnLDu4qzndIp+d8N8z5Xq3XvXbE8lWd73jcNyGPne9QZs5SXqiewOFmsZ/iiTQbL7Wsu79UHfezAPepggA1DkOcbr1xb+XvNNv4vrJZjo/tdp7TrdKnh+F0y2OvqtPtsMb9odPt3sc9zkc87kOdbj1dAJ1ubbzEHve3i4WGGoesB+113LeabXzf3izH54171gW804g47ll2HY77w3GfctyrdZ6SCWzzUydocbzEHvffVHi7KB25mXXiNNrKxv1ZyMfyf6XZxvdDzXJ8bJ9TOrMa203Kwz69RHW4L2unEP3wflH+PiqDuK9A3v0BsM46uB8Q5e93cCNd+C3jZjrtOzXujTfDGPdXgGYe96odsXwIL1U7Nqg88k6t/c9SHsrlK5TXhDyORrQEedZ/cbzUsu7+UnXc4/rh48WGgvWdSSg3lXXiNHnRy+nV3iv/GvSR4rZRdcI5n+1+DVEnDzfKykeJ1nMVae1la+d9RyXrPViejapXNAbmkxeNITZurreyF3FZtgdxe2AeR1lhHNxPGRfjwd9YflLAtzE65cCy7/JUdVzat/n/t9K4HINy44RzCuj3xuWg/PCUMyryM8QPD/lq9VN9imEp3FPwbhT88JAXVf3wQmwhav62/pN4/r6W2j7fa3/V2lrp0bMOf9BZf9D8GXP4MyXq681Laj2g5JXao2CbI8qZMcIzJvCEyjn7Nh8HDxZyboLyfrt577/yOx6Duivc7Hc8jDHu6Sa9xrjVL8TXVuHGtmF5dz4xL8714EWI7qPsYSF6VC9e8Dw4jChbyIuqUbY8f7ULFXmx2TpYvBgTsOpZ+dhCXChPMvEN66m78mup+J/jXCqnZ5JoxfHMuo3Cm3jsLjPPyyJEngI+cZthe03Qu/mCN8rvWPVTNf8rP7mQa3PVXDlEu6b0O+7gXaszD22Y7Hes9gRr4jvPHqpg8b4k6qu8P4G6BdopbTzwGEN69qIv/Oqxe88TRM8S9DHWF7DfhqyPhiELPb+KmPNCr/U+6wvDiDiIvKgacZD9QJT9ncuqcxQLVJbPspwSZdNeSbxyV8kLSywvUKapmyfOUp4K2mR5zaybZ5a3JHiEY8vSGP1GPuVj9uKDbbhcDp/L5HyoLLFvc1nyIZIlxq/PcmSJlQlde+w3WcL2u1MOLIUbbTksSxLdyLDmyQbkBe/v9fKbZFlywYHVixc8xyS6fWHNqxvyImQv+pLDC29fuxcvNlsHixfq/EA9Kx9biAvlSZaVz+0sox5fuvf/eVvxUjk9VfyjFN7EY3eZeY5rD8XzetbdZtheE/TuaZDlvPaoejbvlKAntM97a48B2R7l2qODd63OvCbk8dqjCfXneaEpeNEUvFCw9uojYfXA8cBjDOnBOdvTF9DH+ksLfUHtP/IelLLx4e01Ve3aRtNezw15Pk0pzg1NCDrLbJdIj9oDVLbqsjOmWIfQNrZv8zb+49TGKEtDorcP82zYJQf3KLXxooDlnYeKPY5/qNFJv+V949K9/zH0/tR2dtX3sD1D5qezgj+q7zEsz08jT6zrDkPvV+cXaln3OFF6v3eDw6WKvNhsHSxeLApY9ay8PyEupeviN2W67l9auvf/+fhHS+X0sG8g9uEm5Sm8o3Lr4lngE7eZd+vi94L8Yl1X9VPlc6h03ZD9yxHTdWVg0Q7etTrzliCPdd0lqD/roJcFn5Rea7ixD8ee19ZoXjNe/5Azr/WyjfO8Ngx7sDrX78k7XI94+8cMS+H2bOPDsFsgL6raLfgcpGfD6cWLzdbB4sUpAUvtcyIP1BjKxDfsD2/lf3Lp3v987H5kqZwettMo3XzBwTsqNhzelw+14fxzkF/93iasboIN7fPevIa8ztM45KWe12LYcLwzaeyjjvow2l0+QvNarH2aHyg22FS8hxDfCqYnNB6Nlf816H/9xsAcRnw/td6u0W8sr25tD7FJ9IqZMQq3HHoxP2Lecni+By9GYY2s1nLefBtzb8yLgTkMXcKLARVjb6wu8LA/AsIqs5fxGtnK//ele/9zefjAlU64i0QDtlWdaMfxzbIVxwL7rfFYxjpdBJqV3OU6Wfmxoh4od9Xca3Tl5T4B5ZjH48U3w+xnVc8DYz/j2FFY3uJXK/5cdPgz5/AntUzy5EKoTFLyWZ3PqzLv5Ql1k+fLtNrf2zvFT4QxXnwzqLVzLxtvyNrZi0+ifItqWXc/Yrtjnjx+Go2Kn2gbGS++GaYvu4rT6PEf+x2PXyx/q9WZF+pzyWc2UPaiP6bNCV571eBdaFy4P1vo5nwu72Ehu2tUJtQfc7/ZnKrcAK1wKzk0TD0ReVFVT/Rib3HsObYPIN9sXZ127K9sKb3BkvKjPEV5OKefo7wm5LFv5pLgA59/Z/5xGqPfyKeqPpaxzpe/g+SD8WvTkQ+HNmlfPhzapDUveN5oJubF5R68aBL9TVH+ssOLSw6sqvb55j7nhdrLTW2ff7qQUbkce+eVcnpi2ecTjd1l5jna5xXP61l3m9kz8snebYEsf4Hb56WPZRNonGh15i1BnrfvzPPCkuDFkuCFgnWJ8kJt/U2jM2uPBx5jSE8N3oXa+u8nW3+IPb/XOqJG9UQaUWeq6jNX5Wyywq3mca+ve7T20jk8X+8Q/WXSwd1rDcB88mzFsXFzvU8J3FxWxZjh2DU8ZyjfedVPGRfjwd+9bMDKHhASByl0XKJvyY8WF/OEjMtefT2Fb6oHy+s/vfZ8GLeSlUyL6j9le2Vlbcx+RoNo4++gNvZwhp53iMlnD5bXxjHu4mFaJgSdZTIf6VHnpb27XGr0HdYhtI3t25xH76Y2HiuhjftoiJ1uGPu5aCcd9H7uqNnpkBcp9nNHLa5UzHiwvewUXnxHtPMxfy4OkT9jDn+Ufc/TL3v5iYTEr1VzGe8Vjwk8oXLOvs3HwecWco5jtvy4Y3ccg7qH2B2Hsf+EY7zq/pPVb6/rFWybQcu7Cz14ESLvQtdDlyryYtB2x0s9eNEk+pui/CWHFxccWL14sdk6WLwYE7BUvBDkgZInmfiG15BW/t+C3fGTV8rp4TvucDzzWRiFd1B+wc0CXplfMMdWaUKePSOf7N3/59gdVT9V8b1DdO9Qu9FBtDvyvLAkeLEkeKFgsR7gxZxC/appdGbt8cBjDOmpwbtQfeHlRePxHsDvR9ynHIbvr/Ln8fq1OhdnMuSMA6tXHNdB+7v2WvtV1Re8tWLImVBvb26/80LZVNWZ0NC9OfzG+hyPy6P33fv//J2X95XT0yRasQ8vUZ7Cm9i24Z4JVTyveib0RMGbGGdCzwh6Qvu8N0cir/M0DnkReV35TCjaBHiOVOt/da6G7QZLkIdnQq0P87h4nlfw3lLoftqFImiG9YviGtfsfugXPK9ZmdB5bb+d47D6KZkQYvc7De9Gwe43zHMcyIvN1sHixWkBS/kmIg/UGMrENzyvWflrMK+94r5yengOVrrZgoN3VGIdcFyv0Hntc5x5rWpcrzOCntA+f5DnNW9/yrP34rz2CprXkHdV57XTAPc3Z+49K7sIjpP8rwjpVHr+aAzysfxrYSw+d185PmvfBfoe52K1b87zkNI/vX54DN4Ner/V2ytIsd+aCToxFu3zuFrtPOPNqN1L7Nno8xTCS9WOyqbC43c66+QB5il/RsvD8cTnTdSaAMdLLevuL/3YaS7QuJ+HcjHPgs9DPpb/Mkdvtm9C9eYzVMebxe/l/tKaJ2uRJyxjzojypwVP1DqbYSnc8/CO9eb9di7eW0OE2MaQF6PgRzGoc/G9eLHZ6uTFMM52eDEfY5z9UmfBOcYiwurlB8j+Zt8IessH7+uEy2fBVb/lunA8tjx9QUvj/iDg/vOkMyHtLKvVHV6KhziHqbHCvGS/WrxTc0yUYR8+K/9+kPu1hzth4jdqLuH7Y6z8t4u5pOr5WKzrePHNMNffVe3KOL5MDqjz23jOjvnjnf+fd/hzNjF/lA0P9ZUqNlScc9R6jOdfhVvZrRQ/jUbFT4QxXnwzKH720k9C+Il8Yj9qbw94XsBS/vuKn0aj4ifCGC++GSY/q8Z9RH7y+MXyFp9CnW/nNQXq6txGKP/xfPsHab2h2qsG77z1xjzA/USBcILyPlxxHTANuHkdgPaCFO2sYmOjToH48TeWbwj+2Py84MBSuL11QJq7c9q8WOzBi7KzG1he3SXs2X5CecHrgNOJeXGqBy/YjqbWdKccXiw6sHrxYrN1sHgxL2CpewQwnhzDRP4oWZOJbxao/IIor8b2BJX/RdDr33z/vec5KmMw1P88jYl3bItHWLdanXgaEfEgrEda9/4ru4bBStwPl3lOxv0SxIn+Elgen/M0Qe9+zdkvqXoH45igR+kze22jOVGffmGdjQjrXERY5wWsxHag9RBaEf8M0RqZnpUa4TN6mD/MO8/WjXmsk+z1bsw8mayICcu7X0jZ2dl2r84h8b5cnlie4nzysiIvl+9/SLq0yR+0b6i5mvey33p/G2a9eFZ72bxHpvarvfgJKnaIwRiV2Mds+wuNfXy04JuS21X7nrJFqrNULIcSxaXYCJVDhn8m627nFHJInQVTcijxGYd1o2dJ0KPaOZdz81l3mzXh2WDhXVS2HlVyiG1OKIe8u7pYHqMcMlsAy5ey+plMW3Do8+w71i5Kn+plA2F9r5fsbN6v66ZkZy1r20FYdt4HsvPpEpj1Epj2nNiO5OqsZwU9rJO+hOplY6ysrbCO2KfK7itnvOcIby5Tf5lsN6o/qLVbjeo5WVKe/bys/GcADR8t8b9EPiBdHNekSh8uo/lUAM3rDs1nHZqxn3PbYR8+65Tnccjw2V6LdVB9icedlf9MqOPHSvpGPdM29VE47zHl8KTXnjbrWqcdWJ4tOE+jEOtdxVqo0W8sH3NPW43XYe5pIy9SxjPtxYvN1sHihdKH1NkXtmWwPMnEN6g7YPnXgm7whvs74fI32G+PUZ6VfQrgvV7AZhmcJ8+WzzoSfos6krL58T4R2ibPA4ynaT2JuAye2p9oEA/suztQ7y8i+jBe6q1Wu9ybifesbywKmhjvmwHvdkW8tay7DdR+E7fLtKA5h/veIsPzN2d5W6bXcj+08m+H+v5vA7YJ8BwWus6z8k1RHtdZvC/mxe9UsE47uJdE+aaDG+nCbxk302nfeX4Ww/CpVf7sXjt6d+EqXqp2VGe2mpQXulbmmIsha2XsvzheYsvjPyQ/LZS5ZXfwlvk6sXy18u+Fcf8995fjs7ZSe4jHKE+t9ZU/Ga9/Ri12mXdn9Cj40htvDn3p23lq/9TycL+BfenVOlv52eMa/Xto3Ku98xq8C73r/IeP3HtmffCvO2tgZXvCsTMKMZLKztz16jNYv73GSPLOhg5jrYO8qLrWqRIzthcvRuG+M+RFVd9UL0ZSSLyoUTsnG5MX6pysmgtxvcswQ8/Qqnuya/S7LN4Sr0ms/I+BbvIFD9x7juk3oPZpb7U68cTwKVB7LezbgvyzuWC/75H+s4h7pOpeD2+PtGobqTO4/cJqRoS1FBHWFQHL+tp98H4Yvi2Gf4ZojUzP7p7yfUQP84d5d7+gtSHyWCe5X+C5X+BpiDz2bYkBS+nSV+g7HOesSzcBJvu2YF9leYrzCe7P/nvSpU3+qH2iPG222vlY/vEH2jB/i9azSqYtZN39jGP04ZhoUh62ucGwsfQA5KWQ2y8q4KHcRpxGW53K4zPy0N79riO3q/a9K4KeOfEdy6EXpeFdsG+L4Z/Juts5hRx6keCrkkPGnwfT0LPr2/JiQY9qZ/RtwTZD+gzWOHzPvi0oh9gmh3LofsprQh7L4yXAx74tl3rUj31bFH3KRslrSaVPKbuogm8wesnOmQd03cr22Hm/aTeOOMjOl5XArJfAtOfEvleuztoU9LBOukj1sjFW1lZso1wSeK84eJcIr/JtUf1Brd1qVM/JkvKXiQYrfxZoYD+RS4IPSBf7tlTpw2U0Xwyg+ZJDc9OhGfs5tx324aZTnschw1/KNE9w3F0S8LlP3g91/FhJ36hneg+F7XpLRPPN4vdyf2mNeZ5l2keJebIkyjehDOtalxxYTQEL+yHb9RKtZdZYdpTx4j6i31trYP0WRP3vq8gLtusl0l/WvLohL+4n+pUe6enZVxxYzcznxWbrYPFC6UP1rHxsIS6UJ5n4BnUHLP9ZoBvcfKATLn+D/ZbjNljZzwN4nyNgswzOk2fLZx0Jv0UdKeQMNNomrwAM04lC4v6pM+u8n/NKqPejRB/6Jd1qtct9AfGe9Q3v/kwr+wWA99UV8day7jZQ+03cLurM6fOxSIq9rhDfjCtQH09PmqDyT0J9v/SBcnwpbAJLVIfQdZ6Vf1CUx3UW74vh+v/BAFieP4ZaAz7o4Ea68FvGzXTad2qPG20qeRqHvNR73DDUsolWJ29UO2L5EF6qdmxQeeRd1bXyA5TXhLyytTL2XxwvseXxvy/ZO0c9tw5wef3R62495n/MeAEKN+79c2yjXjGjmdZeZ9gXiVbcG+F1ONYx3nhZuarOFVtSbT9FeegjNE156rwB78dhG/GZXeYJpzH6jXzK5cDFB9twuZylUePvPOUhfxcoD/k7R3mjwl+WCwaX5QLLG+X/k/ehzz7SCRfjOQxD3hh+z7dvgcriWFF+eNwHYpz5bwhYt1qdNKjzO4ljae7aAa0voz0OcaKvAvd9XAOw78F3gU2G90CUfD7t8G5S0KNsuntto/0YS2GvsC4IWIn9uIL3rg3/DNEamZ7dPSPPT0zxTq11VEw/lEWYh3jUuqEh8njvOgYs5ZfpxUSfpDzs27x3jX3V5JzxD+/6xf2XD5GOrM444rebrXY+ln/Ji9owP0zrVCXT9nrOQq19DUbi2ALu3XOIk+91aEKePSMP7d1POHK7at8ru2uXv2M51IT3w9i7NvwzWXc7p5BDzaybr0oOJd6j2N27VnZ51c64d90EmpA+g+XtXau4BUoO8VpdnSdRcoj3rs/0qB/vXSv6xgR9fJZb6VPqHKmCbzB6yc6PVJCdtaytC7Ps/BWw8R1/kYZZL4Fpz4nPh7s66zlBD+uknyBe2RgrayuOrX9e4L3g4D1PeNXeda+z7hz/1uo5WVKebdZW/jedfeAzgg9IF6/lqvThMppPB9D8Ow7N5xyasZ9z22EfPueU53HI8Nk/Eeug+hKPOyv/KWfv+qygGWXXKJxJWXR40utMinfmPORMiooPtl/j6/d7JgV5sdk6WLw4K2DVs/L+hLh6nZ0oiwkzDWuJuRd1wuVvlF2P59cGwJsVsFnu5Emtfdhep+YK1AuU/cn0IZzrFwQ8vofB8l5cfGP9C2VnvP61epX3Pg0H4j6VCHeN8GWZXiuUxQlFumdE3ngftF6/vrWzs721sbJxd231zsqNWtbdxmPiXcg+ibp7K60tcnXNiy1veeOQx3cmTECe0Xgk697LSRPjdnUthP+IX43JkD0vL3atitFcFdbxrFt2s140JWCF7ifYt7nc+dXiR8g9QzY3lK1pWB5b+c8AOfuyF5XjS2EPYv2lmbWTt8a38kuifBPK8F0ynl+lgnXGwa3W/0sO7ibk4beMm+m079T4R3tansYhL7XfQseZPMBb1o5YPoSXTShjvFTnPZYoL9ROcpnyQuwk2H9xvMTWS9jWa7bl0H3EXjECmP+97nzg+5qOQF7InQ+T8I5l+LGKtJ4U5ZEG9rHAfbGTlId1ZPtMons5lrke4z3qUafyzIMJevdE0SeVbVq1jYo/ou5iaTi8O0W8O5mYd4uCdycd3uFcvSh4Z++ejcg7T9dQsKYELK4vlle6yWxRpzy9453Pvf1dGaUp+s1GXyPsGJWzQWtlj2SdvydLCH62BN8UfY/fZvT7GL1jxw/v22fpXZ6skzYI5s3i93JfaeWa2nS3VNUxiZ0tcJJihxucpI5QHipr2FacmLfIp6pONZMElyctTwm2b59ffJMSjIGs2GkOA+2NCbhlF5x8OSjB731ROT6eQDC4oOcwx842JyCvLEBvBnXAIIksHHoFdq0Tbm8RoWDNO7h7GS8ZtzIOMy2ZoNO+U0qw8WYYSnDHpSutTt70CoYawkvVjkop5UBTOBlyQDt1CbA3aSnF2vovjpda1t1fqo57DEh5opjJ1DjEOvQz7r8Vxv3fcMa91VeNe0+pZJmgglwejvvO34fjfu/jHucVHvcoE3jcKyd1L8gljpfY436q8IIwPQ0XIRHbdVtd5mCJLzfLn1mnwnHOOhwu5Nj5+TjkjVMetl9VPc34VFVPi2WsfFNBlDIS8ALI+FUmr49APpb/MMjrX3hROT4OiItBjzlA9Jyg0/KwrdjQoQwRGHg5ZBGHY5JlJvaFxQBYRxzcvRzFGTfSxQ7evNGEdNp3Sl4bb4Yhr08AzSyvVTti+RBeqnZU8pMvu0Ud4wjloew5QXk4nuYoD/up9V8cL7Wsu79UHfdHAO6PFxnWd8ahHNYBaS0b9+OQj+U/AuP+ky8qx8cHF3Bss0w4JuhU455ll+ovKGcHPe7HHdyjMO7t3eG4b+fhfDROeWrdoWTCMcrDforj/pM07sdFPULH/TjA/a3avWfrOzOCbsM5W/wuG/czkI/l/wDG/bEHy/FxcPBZwQslE0LWdd7Ym4V3/Y49ZS/yYM04uHsd7mTc6uA805IJOu07Ne6NN8MY92hg53Hf62BtCC9VOyo7CV9gj3PODOWpOUet63i+x35q/RfHSy3r7i9Vx/0MwP2Z4jllu167fm+z53laC/gmOziNQz6WP1vUH+WE/e/HsWjn2u2VnbXbO7c3bm9trd+9fZzgZ8C7ownw3762dv3u6vrda3c21m6vXe2JPx8fJ0l28n4N5uF6m+UErrHGKA/nNN5MnaHvbu6x7pyM/qMFPNwQRJzTwBcsj895mqB3DxZ8UxuCuNbz1n9qMxV5VQYL9XPeNDf6JkV5hMf1+TSojzmLq7bl9kN+pWg/myuw/RCn0VbPuud3nINZf1hz2k+tf9QaWrUf8grz0NEe97/YQQMvIOS+g/AmqPyvv/je//z3DRrTfBAD85BeHtPTol77fdx+bsRxq8YV9yF16CdPHCAt9TjanZOz7nGE9LBd7RXEo119LtNjg/uzGr+oZ3N/niW8eOhnOuvmdUxeTWfdMiSFwz/yXY1xw68Or9VK/hsszjNcM1m3LIhYtxWvbsqBpZF193seQwrW0YqwEo+vNU92IK8N/5woX6VNVb0Rlh1unMu6+dUvHuQhB9SZFDTk754l+YHjnedDlCV8aOKnYH6748xvbOdDGT2INlC82ev4VXiUrjGXdcvhfvEgLGtPZV9hfQL7COsTLFcxD+cEg2Fjd56+u1n8Xu4zGf22NsY5CnFisB4sj895Yh+Cr3B0DbQLe7ZiNfbmiD8LifiT2OF1V3Yqp0dlz5wTfKo6Hxqumay736WYD1XdvHZGGxrvkVR1NFWw0vo4ttt0wak34p8T5fuVXQiL58NGRDxqry1EnqV2IDe7T5kDOcsztBPZc54m6N03J5ZnvXSJ95fgLNMleO/Ayn876BLf7uwd8N4f0sz+AAdx/vo/B9TeSp6nnds21kLnC8M/qPnCk5vIV+VrZN+yfMrTa1vtcv3MJXn6woiwno0IazsirGciwtqKCOuxiLBi8v7JiLBi1nEnIqzHI8J6OiKsN0WE9YaIsGK24xMRYcXkfUy6YsrVmHSNqiy8GxFWzL4ak643RoQ1qnNtzPE4qvIrZjvGnIdizo8xZU5M3r8+IqyYdRxVGR2T92+JCCumXB1VfSKmHv26iLBGVWeK2e+fiwgr5hjaiggr5lphVPXVmHLi1RFhjeqcth0R1lZEWDH59VREWDH16K2IsEZ13n4hrEXvRIQVU0aPqlw91E2Gp5u8poClzrbw3lUD8lLsXdm+5LioB9JWp/L4nKcJeveaYo9P7V2pPZYFh3dHBT0Mq8xPdZbos/JvLehLuye8cZXPlhsOxH0iEe4a4TN+4zvEr866G90zIq+vILDr21evbm3vbOwsb6/cuLHbH08QrfyuDvjzv9Azn2kvbNtYVees+OzlOOSdoLwJyMPL0jgIbJoAbhurIfxH/A1Rnn2PQ9uyIfCgr1q/sGb2CMsCyqpYA8qnjmV3or1q1+9gTvCwqt/BOxzZPSt4p85aKtnNftVlfibverHGGepnYuW/GvxM/mTxrM5Zsc+q8iVVvq4cFwBlKl86VRf4LG9M4Mu/tzMlXK8WtA9fuoBtzrzKE597SOS7uOuHpmLPhMznWB59aax+yu+HYSnc2Ff50oVEupbrk6d8mmr0G8tjHTluwqyAldgHakf5D1qqGo+H/bZR7rKvtTp3a3k4RyJPOI3Rb+RT1Vg9Si6q4Los+/BblH3sM/cBZ8yjf5nCzRetIF9T9HMVOBj7OeLH31he+Uuq+G8MS+HG9uMxnygg7pqnayAvOJaBF/tC6R/HHVi9eMFzQRrduM2Lkz14ERJT5aTDCy8+Sy9ebLYOFi/mBCy1hmffT5YnmfiGYzZa+b8N+tZPvLicHvbrxfHcoDyFd1SCWR8DPnGbecGsP+jo16qfqktNGoJ3HAetV59HX9bny7Ta3yOv8zQOeRF5vZrz4DGKEdLBu1ZnHsY8mWx18gLjqPC80M+FJHuN9WP1wPHAYwzpCdUX5gDu+yucxcN18FHKQz3Jyg1qHWt9LXQdi30edfwJevfzEdexyqbowVJnbtU4Q17naRzyIvJ6XY2zDt61OvNQn+dxhnm3Wp28qGrbxbxHRhSW1dHy1FlxZe/Afsp9ouqYR7vAs86Yt3qExA5JdY7f6mt9G8e1imlRz7rHGMZEmqB3/8EZ1zFih3jnhqezbr5G5F3wJc+Gf1BxBRRfy2QctyXbybBteZyqWFgqntp+gvW2AlbMc+LM5xiwYsQqMFizEWF559MS2bXWQ8eh4R/U+TRl0/TOpyl7odJjMVYr5iGeYc7jlodyl+Ptoczhi8mwbz9KMLGv2lzfa49ikWxwXlyNPG222vlY/u8/1IZ5huJ+qblJ7VHMUJ46C6vW2hyjJVUcA+ORrY1QH1D9s07l8Rl5aO+WCr4pfUCNF3V/gtLt+I4f/I7lUKK9g2B9wPDPZEnlohtXQcXqSnzmft3oUTZk1c7HivfcZio2N8bjNRu6kkMsa1AOscxV57CVHHp5q10O8ZXVz2SaJzuUDs5645ioX6/YSqwLq7WH9VUlv3jNouLMjUq8Q6OtTuW5/XjP9rMcGVVVt1Syv9d8dZPmK3XPgxcHysp/HsxXH6T5iuOHYR62Kbe34m/iWHC77b3rm5N124GQtjqVx2fkk717hdPeVeOqKbtdTdCn2tGeBxULQ/FzXtDD/Ho99c8G8EeNQ46Tq3xhGg7eBcKLcQ65LlmmecttgXflqPJzRIOVfwpo+CjRcFTwQe3heTRPVaR5KoDmZxya5x2alZxAH1PVZ8riEtZK4LMfiIpTo2IVcp/cgjp+rER+1jM9hnnPfRh+NjMOT3r52Xj3dYT42aDOwHvuw4hnpu4kqNFvLI+yg/1sFhxYvfTizVYnL9L4/rZ5cbwHL/g+COWvoOLfq/1Z9iOOYZtS9rRbrXYZbitvP7vscmz7nsf/nwZd590PdcIt8yvPn/muHCv7HoD3TQ+V1890/9Byag/PeKnGL+tfLJsQhueDlqeyS8MnM73GZ15b+a8X84nyq+T9FvRR4PXUmMCLPPX2PrntvgXa7i+UzAVZVn1fZxroukl0xbwLoCbq5+lVvOfy7WIuVPuZeNfdJx7qrDf23fHim8R6vhvzueqertIZvLW7t9+r+DPl8GdU4id7/FS2M2X3YFuzuvdI2Taq9jes03jxzaD4OdODPyH8xP7Jd1Hh9xMEa0LAQh57/DQaFT8RxnjxzbSgNQU/p5w6Mf4y/mN/Nh55+kVVv35uI5S9eC+f2U3yNlTynPtGL1sNx/C38h+GOesXBry3wPI01F7MegSWV+v5EJ1cwZpycPfyR2bcSBef8ztGv5Uu5I3DxH5B8o6ujrNBrU7e9NIHQ3ip2rFB5ZF3VW3uHIczxOaO/RfHiyd/9uK7Y/uGse+eWru+c3t1eeP2zt2VG9dXVzcGfffV1fWrK9ev375+9+rdnRvrd+8MGv/6xu1rd29fW1m5sb6yvb4y8Prf3bh65+4fEbG8vZL/XB343WM769vXVm/cXtva2bm7euNGL/w2Rmx85wnlT57M789sqlze4E1Q+d+Eeec/0FphXOB7fqw8fO95V/8AWmL6G1vdppAOogfxL4jy9pyY1jWP1ilBq+JxreQ/wsJ3U63Od9Ot7vLIpynCPYPlKe8o5I0TntniN/Y1hGV0TFD5/wl6TZ6OwDf2fUPgxzZjXAo/zmsMa0y8s/J53/49kvnjgDvm3jyOoxQyZvX69as3Vu8sr1/buruztb42aBl3bXn19urW1tb6nbWttWu9ZVx0GbuyvXbj7s7Kyuofidk719YHjf/O1t2r69sba1dvr69cvb018DluZXXr7u07K+vrd9e3Vu+s3R00/o2711dWV27fvXb36o2dre1rg5/jb69tXN+5tnzj+vadrTsDr//2nTtbt+/cvXr1xt07d1fv7gwa/9b19fXlP+p3d9dXr29vbF+tcr+p6dEmv8vumx6DfCzfLORaLuPeWjwrn4eq8x3vM6DezmsZ5eM3BrA2W510sA8F2k9eRWWnnbJfRGVnnLK3qexRp+xbqeysU/aLi7J8JihPN4v/y32l67etPdGehfPoSx9uv8f1GrYHfst9ycp/MfSlzyieF8T31k+UXZ1t8+reUPTZ2mx10mLl1wv83h5zJuqXJ+6fvWyObOfxYmhYX78xQPrGiL4pQZ+ylRjOQZyhYlsJ8mCiFV5fxZ9eNmA+R1F2HyDzZ0C2JMmfCYc/yqZStf+w/yLyB3nHdiacH8rs53iv+cuAdpbrVv4xkCtPP6xh1jItH3gf1eidBBoedWiw8q+F8VqDNTWP94jtfkONBUvqPFCN8tSdhXyOBHnI50JwrqoJGsboN/Ii59MF0Ce4nCXVpnXC0atNJwAWl0d43K++CNrU9sanM92vbha/l/tLV5VuZYn3K1WbqnpxP8Exq/pJ1TY1XlRp07fCelntJdToGf0XlMzabLXzsfyXOvOo2p+oalPH/Qmjx9uf4Hn+XQ59xyvS18uHiOd55UNk9Fk/+t9Btn7lw234SMukqO8xgmd975sB3lc93FnG+uBfgDJfTWVMZr0XyrSojMmuPwdl/kwJ7axzo3xjH6OvI7meKJ7PMq/vuC8gTcoXi/e+GiX1ydMXtO7957M2+F3Ovw88XF5uYYTKcR7LgzzZ2TbFO+RNGaxjDqxjJbBqWXe7ZVl524XWl9dY3wl9/kO0xuJz8ZiHspfXWEr2Yt02W520WPnvqih71bmhUNnLsW2U7PVgebh7yVWW+2W+mc9/32rnDSjWi1wfdNx32gqvr+JPr9hZvC+sYvko/hwfIn9UjI699l3FT6U3qBiqDcrDOYHHs/IH93xGUb4rn1GON2XlPyj0YmXHw339D5XYkJDWCUGrsk0h3JcCLbFsnj8GMvTySzrpGDWbp5XHmB6qvJ1XsW88u+ebi7K97II/RW06I2j27IJWvvmSNsyfrWAXxPVMiF1QnQfgdfzPO3OWlamXwOQzQcqu5NlZevm+sv+T50ercCu/GSs/V5FWLx4C4le+3ixXrK9/xOF9bPrYJjsl6PNwe/aGhYq0er5diF/pcZ4v24Dss9dS+7KF+iQ2qDy2q+LPwhD549lnJ0V9vf7j+cjhWFSxlzDWAvNnmP1n0uFPL5/AEPu+F09cnYtW/MEzvoPmT0z7vhdjCuWP8gflc0E1yKtq32edxMqPgX5w7CUaZi3Tc3JV+z7TYOWnCrwDtO/fVud3LCkbfo3ycM5lWzDOhWzfx/mlH/v+hwNtwdymyr7vtamy76s4F9yvFqFND+3791Iv+35om9q6Ce37qq/as7prwrPvW/n7oQ1D7mRAmKyve3cmGBws3+ssd8idCawDP+zUZ6Eifb30StaBlV6ZEZ5JURfW560fXgW5vfySTnhsY8f155e0OvOs7HoBI3VMDWV/55hUMyW8uf6SauV4LfyZwLMvK57Ves9oU2OL18JeHIY8bbY6abHyn+P0RStTFoeBx5bquyrWTmjfDVkTebhRfpWdpQ6lNbVt2sPdyzbNMkjZpj3c6t4WK3+yIq29YukfJ1rVvQLe2d5h6OHIg4lWeH0Vf1SsdIxtz3o4xkr37Ognh8ifGYc/yq7i9R8vrj6OM2UH8PZhhtl/5hz+9JJbIfxBmTnr8MezA8wNkT9e/1H2Uq//KP0O10jHiT9qTlHr3JAz0CoOKtdjMtN237LYGF8q1i9qb2EG4H/ZS3rTGroPg3BtLyC67/3qyvXlq6sbK+tb2ys7gz/7snr7zrXbq3du39i6sbZyfWPg+G9c27l7e+vG1s61tZ3bO7dvV/H9TxHPRO29cHz7RDEJdmPd2dgou3sWY4TxWMJxyD5FXw/jiWMHKp9r5VOsbKzIqzJY3n4Crhu4PMLj+vx5IR9U23L7DTvWJ+5lsoz2Yn1+q9N+Me4nqFHeWKbtz7z28fYiER7bHF/2aff+P+/vQ2tBZSNSbctjWp1L2O/j9rsjjls1rrgP4ZoXbe3W7oMaR7v6WOavwdku8zdJB9jV+TI9Nrg/q/GLejj351nCizE/p7NuXsfk1TDjXGGd+A5edccJ/zdYnGe4ZrJuWRCxbite3VQcF7V/xmOoagxeBWvUYnOpcxhV2lTVG2HZHhnv+cTAU3aWiec0oyF/9w9Ifnh3MKAs6bJ1w/z2Y878ZrxQ89sg2kDxZq/jV+Hx7kI6EhEPwrL2rGpbZn2C5SrmKX+g1LZ7o9/sHmXxsNF+jeXxOU/sM/+vHV1D2bOUvcaLjzQt6EkxHw4jFrCKFabsYFXnQ76DYy5N3dw7OLx2VucLPFiNirCmRV6KNvXskYhf+YD1K7sQFs+HvFep/ofiUTGNQ+RZovG0K8/wbhS1x8TyDO1EHb7+9O53EsuzXrrEfylZi5TpEmwLtfK/99I2zN9z9k15Lw5p5hjbB3H++sMBtbeS52nnto210PnC8A9qvgjdx2F5ht+yfMrTa1vtcv3MJXn6woiwno0IazsirGciwtqKCOuxiLBi8v7JiLBi1nEnIqzHI8J6OiKsN0WE9YaIsGK24xMRYcXkfUy6YsrVmHSNqiy8GxFWzL4ak643RoQ1qnNtzPE4qvIrZjvGnIdizo8xZU5M3r8+IqyYdRxVGR2T92+JCCumXB1VfSKmHv26iLBGVWeK2e+fiwgr5hjaiggr5lphVPXVmHLi1RFhjeqcth0R1lZEWDH59VREWDH16K2IsEZ13n4hrEXvRIQVU0aPqlw91E2Gp5u8poCl4rnx3lUD8lLsXdm+ZNmd4By7EPcx8QwLx9v7wWKPT+1dqT2WBYd3RwU9DKvMT7XsDtqfKuhLuye8cVXFcKtlnbhPJMJdI3zGb3yH+OcEPUb3jMjr56zE9fXtq1e3tnc2dpa3V27c2O2P6owkvqsD/vxPnWtU+3XG68U0vF71zvJZ3jjk8Rm3CcgzGvOxc5roP5mI/hD+I/6GKM++x6Ft2RB4OEZWP7Bm9gjreNY5BlBOKJ86lt2J9qpdv4M5wcOqfgf/3JHd6hzfrOCdkt3sV13mZ/KvXqpxhvqZWPmPgp/Jvyme1Tkr9llVvqTK15VjEaFM9e5Anaa8MYEv/97OlHC9fhXaJySOhjrvkth3cdcPzYvT4c3nWL5qnA4PtzojP0yfPOXTVKPfWF7F/FSyyL5N7AO1o/wHLSkfmWnKK4v/xnKXfa1RvrM/E86RyBNOY/Qb+ZTjew/EB+Fy+FwmF0PvPsUzxSb72GfuvzpjXsX3QNyvbN37nzgW+m4/V2fbsZ+HxNFQ/pIqfgjD8uIO5InHfBp9qs2LEz14cZLo7xWfmfWP4w6sXrzguSCNbtzmxckevFgk+nvFIGFenHBg9eLFZutg8WJOwFJrePb9ZHmSiW84hpSVPwZnhB78tHJ62K9XxW5YcPAmHrvLzHPUrxXP61l3m2F7TdC7swVvlH6t+im+Y/16XtAT2ufRl/X5Mq329wOKd7+a8+AxiiPSwbtWZx7G3ZlsdfICY+zwvKDi9ZwSvFCwTlCeOhvDdj6sB44HHmNIT6i+MAdw/0uFs3gqvpnSHTHGDo/dFOPM+lroOhb7fEfsf3q36oyzqutYL363gqXO3A4xntG6Gmfq3gSlz/M4w7xbrU5eVLXtYt4jEWF9fkRYVkfLU2fFlb2DY5P3ioXsjXm0C/wDZ8xbPUJih6Q6x2/1tb6N41rFtKhn3WOsI5YUvXuVM65jxA7xzg1PZ918jci7jRrhs3rgO8Q/qLgCXtxp5KuKpcl2MmxbHvMqxpWKE7afYL2tgBXznDjzOQasGLEKDNZsRFje+bREdq310HFo+Ad1Ps27K0PxTtkLlR6LcaYxD/EMYx43WJaHcpdjbKLMmaI8FdPP8rCv2lzfa4/iy0mf9+Jq5Gmz1c7H8uc+vQ3zT9GaWc1Nao9ihvLUWVi11uYYLaniGBiPbG2E+oDqn3Uqj8/IQ3v3NY4+oMaLuv9L6XYcRxq/YzmUaO8gWB8w/DNZUrnoxlVQsboSn7lfN3pC7wk8VrznNkP68Py+JbOhKznEsgblEMtcdQ5byaGXt9rlEF9Z/UymebJD6eCsN46J+vWKrcS6sFp7WF9V8ovXLCrO3KjEOzTa6lSe24/3bP+SI6Oq6pZK9vear76L5iuMQ6n21DkOlJX/HrDxni3mLtWm3N7Yptzeir+JY8Httveub07WbQdC2upUHp+RT/bubzrtXTWumrLb1QR9qh3x3qOE84LLz3lBD/Prh6h/NoA/ahxynFzlC9Nw8C4QXoxzyHXJMs1bbgu861KVnyMarPwHgYaPEg1HBR/UHp5H81RFmqcCaP6wQ/O8Q7OSE+hjqvpMWVzCWgl89gNRcWpUrELuk/8E6sh77tOCZhzDvOc+DD+bGYcnvfxseO+gqp+NugNqmPHMkBch+2QoO9jPZsGB1Usv3mx18iKN72+bF8d78ILvFel1R4m3P8t+xDFsU8qedqvVLsNt5e1noz56TNSJx/+vgK7zS5/WCbfMrzx/Hqc8K/tvAd5vflp5/Uz3Dy2n9vCMl2r8sv7FsglheD5oeSq7j6fsnmrmtZX/hJhPlF8l77egjwKvp8YEXuSpt/fJbfefoO1+u0SXzrLq+zrTQNd3EV0x7wKoifp5ehXvufyemAvVfqbRlZf7xEOd9ca+O158M8yYz1X3dJXO4K3dvf1exZ8phz+jEj/Z46eynSm7B9uaxwUsZduo2t+wTuPFN4Pi50wP/oTwU90DqfhZdncrwkIee/w0GhU/EcZ48U3i+wh2+Tnl1Inxl/Ef+7PxyNMvqvr1cxuh7DWZjHYTvG/TG2u9bDUcw9/KX4K9hQ2y1aTeW2B5GmovZj0Cy6v1fIhOrmBNObh7+SMzbqSLz/kdo99KF/LGYWK/oI3U98ErXqp2bFB55F1VmzvH4QyxuWP/xfHiyZ+9+O58Oeh4z79rAdxW+5s8TRW/zabF5Y3XE1T+s2Dcfza07fNlBb683KuccrWS/8/DEO/GW53vplvd5cda3eUN90yrm0bLOwp52DfzNFv8Rn4hLKNjgso/CrIxT0fgG/u+IfAfIfwddIt3ODYY1ph4Z+Xz9vm8gsZd/R1wx97fex4nwcd3TNuraD7L0xTWDWCV1XtMwFbtcTQA1lEH1rQDayYQlocbaR0n+NbfJkvgT1P5ueI39ucpQQ/356dg/L/10zvLGMw3QZlnA2SE0TSPeaI82m24vNU1x/lcgXPXzgh4YuuPZXRjXzD8MeSf4RrUWI3RJh6s+UBYxk9s3/z5KwbT1qtcB7PNYz0R/+4aPg09u31voeXz1PDH6HuGa1B9T9XN63tYnvuegrUQCMv4qfrbXBoerLFcz0p4gPjxN8p1nP/sW5bZX/vpnXAUv3AOs7loV+eFvBnKOwZ5s0Tv8VY3vQhrgeg9TvTa3Kv6fEPgnyf8iEvh53n5mCh/TJTP+8p7iKeT4ltsX+Npruv8/xDvwYAkUgcA\",\n+ \"debug_symbols\": \"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\",\n \"file_map\": {\n \"3\": {\n \"source\": \"use crate::cmp::{Eq, Ord};\\nuse crate::convert::From;\\nuse crate::runtime::is_unconstrained;\\n\\nmod check_shuffle;\\nmod quicksort;\\n\\nimpl<T, let N: u32> [T; N] {\\n /// Returns the length of this array.\\n ///\\n /// ```noir\\n /// fn len(self) -> Field\\n /// ```\\n ///\\n /// example\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let array = [42, 42];\\n /// assert(array.len() == 2);\\n /// }\\n /// ```\\n #[builtin(array_len)]\\n pub fn len(self) -> u32 {}\\n\\n /// Returns this array as a slice.\\n ///\\n /// ```noir\\n /// let array = [1, 2];\\n /// let slice = array.as_slice();\\n /// assert_eq(slice, &[1, 2]);\\n /// ```\\n #[builtin(as_slice)]\\n pub fn as_slice(self) -> [T] {}\\n\\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.map(|a| a * 2);\\n /// assert_eq(b, [2, 4, 6]);\\n /// ```\\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array along with its index,\\n /// returning a new array containing the mapped elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let b = a.mapi(|i, a| i + a * 2);\\n /// assert_eq(b, [2, 5, 8]);\\n /// ```\\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\\n let uninitialized = crate::mem::zeroed();\\n let mut ret = [uninitialized; N];\\n\\n for i in 0..self.len() {\\n ret[i] = f(i, self[i]);\\n }\\n\\n ret\\n }\\n\\n /// Applies a function to each element of this array.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// let mut i = 0;\\n /// a.for_each(|x| {\\n /// b[i] = x;\\n /// i += 1;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\\n for i in 0..self.len() {\\n f(self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of this array along with its index.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// let a = [1, 2, 3];\\n /// let mut b = [0; 3];\\n /// a.for_eachi(|i, x| {\\n /// b[i] = x;\\n /// });\\n /// assert_eq(a, b);\\n /// ```\\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\\n for i in 0..self.len() {\\n f(i, self[i]);\\n }\\n }\\n\\n /// Applies a function to each element of the array, returning the final accumulated value. The first\\n /// parameter is the initial value.\\n ///\\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\\n ///\\n /// ```rust\\n /// let a1 = [1];\\n /// let a2 = [1, 2];\\n /// let a3 = [1, 2, 3];\\n ///\\n /// let f = |a, b| a - b;\\n /// a1.fold(10, f); //=> f(10, 1)\\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\\n ///\\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\\n /// ```\\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\\n for elem in self {\\n accumulator = f(accumulator, elem);\\n }\\n accumulator\\n }\\n\\n /// Same as fold, but uses the first element as the starting element.\\n ///\\n /// Requires the input array to be non-empty.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [1, 2, 3, 4];\\n /// let reduced = arr.reduce(|a, b| a + b);\\n /// assert(reduced == 10);\\n /// }\\n /// ```\\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\\n let mut accumulator = self[0];\\n for i in 1..self.len() {\\n accumulator = f(accumulator, self[i]);\\n }\\n accumulator\\n }\\n\\n /// Returns true if all the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 2];\\n /// let all = arr.all(|a| a == 2);\\n /// assert(all);\\n /// }\\n /// ```\\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = true;\\n for elem in self {\\n ret &= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Returns true if any of the elements in this array satisfy the given predicate.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr = [2, 2, 2, 2, 5];\\n /// let any = arr.any(|a| a == 5);\\n /// assert(any);\\n /// }\\n /// ```\\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\\n let mut ret = false;\\n for elem in self {\\n ret |= predicate(elem);\\n }\\n ret\\n }\\n\\n /// Concatenates this array with another array.\\n ///\\n /// Example:\\n ///\\n /// ```noir\\n /// fn main() {\\n /// let arr1 = [1, 2, 3, 4];\\n /// let arr2 = [6, 7, 8, 9, 10, 11];\\n /// let concatenated_arr = arr1.concat(arr2);\\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n /// }\\n /// ```\\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\\n let mut result = [crate::mem::zeroed(); N + M];\\n for i in 0..N {\\n result[i] = self[i];\\n }\\n for i in 0..M {\\n result[i + N] = array2[i];\\n }\\n result\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Ord + Eq,\\n{\\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\\n /// sort any type, you should use the `sort_via` function.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32];\\n /// let sorted = arr.sort();\\n /// assert(sorted == [32, 42]);\\n /// }\\n /// ```\\n pub fn sort(self) -> Self {\\n self.sort_via(|a, b| a <= b)\\n }\\n}\\n\\nimpl<T, let N: u32> [T; N]\\nwhere\\n T: Eq,\\n{\\n /// Returns a new sorted array by sorting it with a custom comparison function.\\n /// The original array remains untouched.\\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\\n ///\\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let arr = [42, 32]\\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\\n /// assert(sorted_ascending == [32, 42]); // verifies\\n ///\\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\\n /// assert(sorted_descending == [32, 42]); // does not verify\\n /// }\\n /// ```\\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\\n // Safety: `sorted` array is checked to be:\\n // a. a permutation of `input`'s elements\\n // b. satisfying the predicate `ordering`\\n unsafe {\\n let sorted = quicksort::quicksort(self, ordering);\\n\\n if !is_unconstrained() {\\n for i in 0..N - 1 {\\n assert(\\n ordering(sorted[i], sorted[i + 1]),\\n \\\"Array has not been sorted correctly according to `ordering`.\\\",\\n );\\n }\\n check_shuffle::check_shuffle(self, sorted);\\n }\\n sorted\\n }\\n }\\n}\\n\\nimpl<let N: u32> [u8; N] {\\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\\n /// the given array is interpreted as-is as a string.\\n ///\\n /// Example:\\n ///\\n /// ```rust\\n /// fn main() {\\n /// let hi = [104, 105].as_str_unchecked();\\n /// assert_eq(hi, \\\"hi\\\");\\n /// }\\n /// ```\\n #[builtin(array_as_str_unchecked)]\\n pub fn as_str_unchecked(self) -> str<N> {}\\n}\\n\\nimpl<let N: u32> From<str<N>> for [u8; N] {\\n /// Returns an array of the string bytes.\\n fn from(s: str<N>) -> Self {\\n s.as_bytes()\\n }\\n}\\n\\nmod test {\\n #[test]\\n fn map_empty() {\\n assert_eq([].map(|x| x + 1), []);\\n }\\n\\n #[test]\\n fn mapi_empty() {\\n assert_eq([].mapi(|i, x| i * x + 1), []);\\n }\\n\\n #[test]\\n fn for_each_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_each(|_x| assert(false));\\n }\\n\\n #[test]\\n fn for_eachi_empty() {\\n let empty_array: [Field; 0] = [];\\n empty_array.for_eachi(|_i, _x| assert(false));\\n }\\n\\n #[test]\\n fn map_example() {\\n let a = [1, 2, 3];\\n let b = a.map(|a| a * 2);\\n assert_eq(b, [2, 4, 6]);\\n }\\n\\n #[test]\\n fn mapi_example() {\\n let a = [1, 2, 3];\\n let b = a.mapi(|i, a| i + a * 2);\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn for_each_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n let mut i = 0;\\n let i_ref = &mut i;\\n a.for_each(|x| {\\n b_ref[*i_ref] = x * 2;\\n *i_ref += 1;\\n });\\n assert_eq(b, [2, 4, 6]);\\n assert_eq(i, 3);\\n }\\n\\n #[test]\\n fn for_eachi_example() {\\n let a = [1, 2, 3];\\n let mut b = [0, 0, 0];\\n let b_ref = &mut b;\\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\\n assert_eq(b, [2, 5, 8]);\\n }\\n\\n #[test]\\n fn concat() {\\n let arr1 = [1, 2, 3, 4];\\n let arr2 = [6, 7, 8, 9, 10, 11];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\\n }\\n\\n #[test]\\n fn concat_zero_length_with_something() {\\n let arr1 = [];\\n let arr2 = [1];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_something_with_zero_length() {\\n let arr1 = [1];\\n let arr2 = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, [1]);\\n }\\n\\n #[test]\\n fn concat_zero_lengths() {\\n let arr1: [Field; 0] = [];\\n let arr2: [Field; 0] = [];\\n let concatenated_arr = arr1.concat(arr2);\\n assert_eq(concatenated_arr, []);\\n }\\n}\\n\",\n"},"problem_statement":{"kind":"string","value":"Rework `inc_rc`, `dec_rc` and how arrays are handled in brillig in general\n### Problem\n\n`inc_rc` and `dec_rc` are a common source of bugs in SSA code generated by the compiler. They require special handling since they are effectively implicit variables attached to each array in unconstrained code.\n\n### Happy Case\n\nNow that runtimes are separated before SSA we could represent arrays differently in acir & brillig. In Acir they can continue to be represented as normal arrays, while in brillig we could lower them as a tuple of `(&mut Field, [T; N])` where the first element of the tuple is the reference count represented as a mutable field value, and the second is the array itself. If we do this, reference counts now need much fewer special handling or optimizations since they'll be handled by mem2reg along with other references.\n\nThis could make it more difficult for optimizations like deduplication to insert extra `inc_rc` equivalents since they'd have to find the integer that represents the array's reference count instead of it always being attached to the array.\n\nUncertain how much code improvement this will bring or if it will improve optimizations so I labeled this as \"experiment\" with rather than a \"lets definitely do this.\"\n\nEDIT: See comments below for some alternative approaches.\n\n### Workaround\n\nNone\n\n### Workaround Description\n\n_No response_\n\n### Additional Context\n\n_No response_\n\n### Project Impact\n\nNone\n\n### Blocker Context\n\n_No response_\n\n### Would you like to submit a PR for this Issue?\n\nNone\n\n### Support Needs\n\n_No response_\n"},"hints_text":{"kind":"string","value":"Just to make sure I understand, you're not suggesting that `inc_rc` will disappear from the code, but rather that instead of figuring out which array it needs to act on, with the ref count being an internal part of the array in the Brillig VM, it will instead be like the length of a BoundedVec, a number passed around in the SSA together with the array used for storage. But where the `inc_rc` and `dec_rc` are inserted into the SSA will remain a source of speculation about how the array is going to be used, as it is now. \n\nI'm asking because I have difficulty understanding some of the SSA generated from the test that fails in #7297 \n\nFor example `copy_mut` seems to insert an `inc_rc` because it receives a `mut array`, but it doesn't seem to account for the possibility that the array might not be mutated, and the count stays higher after the call no matter what. \n\nTake this example:\n\n<details>\n<summary>maybe_mut</summary>\n\n```rust\nuse std::mem::array_refcount;\n\nfn main() {\n let mut array = [0, 1, 2];\n maybe_mut(array, false);\n maybe_mut(array, true);\n println(array[0]);\n println(array_refcount(array));\n}\n\nfn maybe_mut(mut array: [Field; 3], should_mutate: bool) {\n if should_mutate {\n array[0] = 4;\n }\n println(array[0]);\n}\n```\nIt prints 3 as the final refcount in `main`, because of how `maybe_mut` looks like:\n\n```rust\nbrillig(inline) fn maybe_mut f1 {\n b0(v0: [Field; 3], v1: u1):\n inc_rc v0\n v2 = allocate -> &mut [Field; 3]\n store v0 at v2\n jmpif v1 then: b1, else: b2\n b1():\n v3 = load v2 -> [Field; 3]\n v6 = array_set v3, index u32 0, value Field 4\n store v6 at v2\n jmp b2()\n b2():\n v7 = load v2 -> [Field; 3]\n v8 = array_get v7, index u32 0 -> Field\n call f2(v8)\n return\n}\n```\n\n</details>\n\nDoes your proposal address the speculative nature of `inc_rc`? As it stands it's primary goal is to prevent against accidental modification, at the cost of doing more copies\n\nI wonder if we could have a concept of `drop`, that is to understand when a reference goes out of scope, and decrement the RC at that point, and increment at the point where a borrow is made. For example I see `maybe_mut` emits an `inc_rc` because there is a possibility of mutation, while `borrow` in the test does not. Now, if I change `borrow` to _return_ the array it borrowed then it still doesn't increase the count, but the caller does on the returned value. Then, if I change it to return a struct wrapping the array, then both `borrow` and the caller increases the RC, with the two consecutive increments later being deduplicated. By contrast, we could increment the RC where in the caller when it passes an array to its callee, and decrement it if/when that reference is finally dropped, whether at the end of the called function, or when the returned structure wrapping it goes out of scope. So we would make simpler-to understand rules about inserting them, and perform the optimisation to remove them later, once we have the full picture. I can imagine identifying when a value is dropped is not trivial, though.\n\n(The deduplication of increments is a counter example for where my assumption that observable side effects - the printing of the ref count in this instance - should be the same between the initial and final SSA breaks down).\n> But where the inc_rc and dec_rc are inserted into the SSA will remain a source of speculation about how the array is going to be used, as it is now.\n\nNo, this proposal is to remove `inc_rc` and `dec_rc`\n\n> I wonder if we could have a concept of drop, \n\nI've considered trying to track when the arrays may be dropped in the past but as soon as the array gets stored in a mutable reference - which is the case with most arrays being mutated anyway - we lose almost all ability to track them since we'd have to delegate to mem2reg. You could also say we do have a drop of sorts since we do issue some `dec_rc` instructions, just only where we \"know\" a value won't be used afterward, e.g. an array parameter at the end of a function where no values containing arrays are returned. (\"know\" is in quotes due to the negative RC issue - clearly some assumptions are incorrect).\n\n> (The deduplication of increments is a counter example for where my assumption that observable side effects - the printing of the ref count in this instance - should be the same between the initial and final SSA breaks down).\n\n`can_be_deduplicated` should be `false` for both `inc_rc` and `dec_rc` so we shouldn't be deduplicating these instructions. We may deduplicate a constant `make_array` though - in which case we should add an extra `inc_rc`.\n\n> we shouldn't be deduplicating these instructions.\n\nThe deduplication of consecutive RC instructions happens [here](https://github.com/noir-lang/noir/blob/25b989fe5c2a247f66cefe09587526570ce7d71a/compiler/noirc_evaluator/src/ssa/opt/die.rs#L658-L665), `can_be_deduplicated` is not involved, it's a special case. \n\n> we do issue some dec_rc instructions, just only where we \"know\" a value won't be used afterward, e.g. an array parameter at the end of a function where no values containing arrays are returned. \n\nAs another example of why it's difficult to handle this in SSA when the RC is also in the hands of the Brillig VM, here's the SSA of such a function from my experiment:\n\n```\n v11 = load v4 -> [Field; 3]\n inc_rc v11\n ...\n v18 = load v4 -> [Field; 3]\n v20 = array_set v18, index u32 0, value Field 6\n store v20 at v4\n v21 = load v4 -> [Field; 3]\n dec_rc v21\n```\nSo it originally inserted an `inc_rc` and a `dec_rc` acting on the input `v4` (one of the `array: &mut [Field; 3]` parameters). What it can't know, is that `v20` may be a new array (I suppose it could, because after an `inc_rc` it will be, but in general I assume it doesn't), and that after `store v20 at v4` overwrites `v4` with this new array, `dec_rc v21` acting on a freshly loaded reference from `v4` will potentially act on an array different from what the original `inc_rc` was issued for. \n\n> No, this proposal is to remove inc_rc and dec_rc\n\nThanks for making that clear. I feared that for the same reason as above, if `dec_rc` was acting on a tuple member instead of the array it would be susceptible to fall victim of the same gotchas with forwarding rules and act on the values made by the copy-on-write procedure than the original. \nFor the record, the RC rules that would make more sense to me would be along the following lines:\n* Generally the caller should make the increment when they pass a borrowed value to a function, rather than the callee guessing whether to inc or not\n* `fn borrow(array: [Field; 3]`: the caller should increment the RC before passing `array`, and at the end of the method it can be dropped because it goes out of scope and doesn't get stored\n* `fn borrow_mut(array: &mut [Field; 3]`: unlike `borrow` I would not consider this an additional reference, just use _write_ semantics and modify the original without increasing the RC\n* `fn copy_mut(mut array: [Field; 3]`: the caller should increment the RC because it's a borrow and _copy-on-write_ should be used\n* `fn borrow_mut_two(array1: &mut [Field; 3], array2: &mut [Field; 3]`: like `borrow_mut`, I would argue that the RC should _not_ be increased at all (currently it increases it once for array2). That's because we want _write_ semantics and it should be the users' responsibility whether they pass reference to the same array or not, I don't think copies should be made unless there are other borrows such as `borrow` and `copy_mut` do, which imply _copy-on-write_. The effect of writing to the original seems to be the same anyway.\n\nThen we could let the SSA figure out which inc/dec pairs it can get rid of for optimisation, but it would make it clear when the RC is increased and why. \n\nReturning the array or storing it in a data structure should cancel the decrement.\n\nIs this 🌈 and 🦄 thinking?\nOne more observation about placing the `dec_rc` at the end is that the Brillig VM also modifies the RC of the original array during the copy procedure [here](https://github.com/noir-lang/noir/blob/25b989fe5c2a247f66cefe09587526570ce7d71a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs#L72-L73), so these two alone can end up bringing the RC to zero:\n\n* if the final `dec_rc` acts on the original array after a copy was made, it's double decrementing\n* if the final `dec_rc` acts on the copy of the array, it's bringing it from 1 to 0 immediately\n* the final `dec_rc` should act on the original array, and only if no copy ended up being made\n\nThis might be fixed by https://github.com/noir-lang/noir/pull/7297#issuecomment-2640467338\n\n\n> Is this 🌈 and 🦄 thinking?\n\nNot necessarily but there are a couple of issues / practical concerns. The scheme you gave is more or less how they're intended to behave but have been changed over time as we were pressured to create smaller brillig bytecode sizes. Increasing the ref counts on each immutable function was leading to a bytecode explosion since it happens much more often and we cannot usually optimize out these cases. A related issue is that Noir doesn't have the concept of an immutable borrow which would normally be the case you'd keep the ref count the same - where a conceptual clone like we'd have where you pass by value you do normally increase it.\n\nSo we wanted to change where ref counts are to find places where less of them were needed and they were easier to optimize out. That's why we have both inc & dec within a function since then it is easier to identify when we can remove them as a pair. Versus if we had the inc outside the function we can't do that unless the function is inlined.\n\n> Returning the array or storing it in a data structure should cancel the decrement.\n\nHow do you know if the array was returned or stored in a data structure (and returned)? Usually references are involved so you won't know if the array in this reference is the same or not. Our answer for this currently is to say if the function returns any types containing an array of the same type then we have to pessimistically assume the array in question may be returned. This should lead to counts drifting up, not down, but I point it out as something to keep in mind that we probably can't be perfect here.\n\nAnyways - this was mostly to explain why we have our current system / how we got here since I think once you know that its easier to make changes to fix it or tear it down if necessary.\n\nEDIT: Clarification on why we increment on mutable values currently. In the current scheme to minimize unnecessary inc/decs we:\n- Assume all array values are passed as immutable references by default.\n- Only when the array is taken by mutable value, copied into a let binding, or into multiple `&mut` references do we increase the ref count. This is so if you have a deeply nested series of functions with one mutation deep in the call stack, that we don't need to inc/dec the rc for every function in between.\nAh, some details I left out from our current scheme:\n- Noir has no concept of moves so we approximate by incrementing ref count where an array may be copied. This is wherever a new variable binding may introduce an alias to the array. So let bindings and function parameters.\n> The deduplication of consecutive RC instructions happens [here](https://github.com/noir-lang/noir/blob/25b989fe5c2a247f66cefe09587526570ce7d71a/compiler/noirc_evaluator/src/ssa/opt/die.rs#L658-L665), can_be_deduplicated is not involved, it's a special case.\n\nHonestly, I don't see the correctness argument for that optimization - I think we should remove it entirely. Especially since counts are underflowing, one reason could be that these extra inc_rcs are required.\n\n> As another example of why it's difficult to handle this in SSA when the RC is also in the hands of the Brillig VM, here's the SSA of such a function from my experiment:\n> \n> v11 = load v4 -> [Field; 3]\n> inc_rc v11\n> ...\n> v18 = load v4 -> [Field; 3]\n> v20 = array_set v18, index u32 0, value Field 6\n> store v20 at v4\n> v21 = load v4 -> [Field; 3]\n> dec_rc v21\n\nYeah, this seems bad. It makes me think that we need a larger redesign as well since right not trying to fix it up seems to me like it'd just be \"garbage in, garbage out.\"\n\n**Move & Copy Elision Optimization scheme**\n\nI think going forward for more confidence in correctness & still having some optimizations we could:\n- Start with a scheme we have more confidence to be correct e.g. the one you described where we don't increment rc for references but do for passing by value.\n- Remove existing optimizations on ref counts. We won't need them.\n- Add an analysis to determine where an array is moved versus where it needs to be copied. This will need to be done before we issue inc/decs so before ssa-gen. We should issue explicit `clone(array)` IR nodes at this point (which probably just inc_rc internally).\n- Add an analysis to try to figure out which functions can immutably borrow an array (or just add immutable borrows to the language) so that those functions will not need to conceptually clone the array (inc_rc) either. This could be part of the previous pass since otherwise their ordering would be important since the move pass may issue a copy for a function that later turned out could have immutably borrowed the array. Note that an immutable borrow analysis will have to be conservative. If we have a function like `fn foo(a: [Field; 1], b: &mut [Field; 1])` we have to assume `a` and `b` could refer to the same array so `a` still can't be borrowed even if never mutated.\nSounds good! \n\n> since right not trying to fix it up seems to me like it'd just be \"garbage in, garbage out.\"\n\nI hope that this particular issue will be fixed by https://github.com/noir-lang/noir/pull/7297\n**Expose immutable references directly scheme**\n\nSpoke with @michaeljklein and @aakoshh and another option we're more strongly considering now is to add immutable references to Noir. If we do that:\n- Any by-value use of an array type would incur a copy\n- We would need to add a cloning operation to the language which would clone the array and unwrap it from the reference\n- Where arrays are cloned becomes a user's issue for optimizing their own code.\n- The compiler is simpler, we need fewer optimizations on RCs and testing on arrays becomes easier.\n- We could remove RCs entirely, copying every time a full array value is used as mentioned above, or keep rcs and just increase the reference count on a clone. This later case may be an easier transition but the compiler could still be copying unnecessarily since we'd still not be able to determine in all cases when to `dec_rc` if references are involved. For the always copy case above though, you could argue users still unnecessarily copy e.g. if using arrays in generics instead of array references in generics, although this could also be considered a user problem in that case.\n\nThis is something I'd support experimenting with. We would have to update libraries to take references where possible but could compare performance afterward.\n\n"},"all_hints_text":{"kind":"string","value":"Just to make sure I understand, you're not suggesting that `inc_rc` will disappear from the code, but rather that instead of figuring out which array it needs to act on, with the ref count being an internal part of the array in the Brillig VM, it will instead be like the length of a BoundedVec, a number passed around in the SSA together with the array used for storage. But where the `inc_rc` and `dec_rc` are inserted into the SSA will remain a source of speculation about how the array is going to be used, as it is now. \n\nI'm asking because I have difficulty understanding some of the SSA generated from the test that fails in #7297 \n\nFor example `copy_mut` seems to insert an `inc_rc` because it receives a `mut array`, but it doesn't seem to account for the possibility that the array might not be mutated, and the count stays higher after the call no matter what. \n\nTake this example:\n\n<details>\n<summary>maybe_mut</summary>\n\n```rust\nuse std::mem::array_refcount;\n\nfn main() {\n let mut array = [0, 1, 2];\n maybe_mut(array, false);\n maybe_mut(array, true);\n println(array[0]);\n println(array_refcount(array));\n}\n\nfn maybe_mut(mut array: [Field; 3], should_mutate: bool) {\n if should_mutate {\n array[0] = 4;\n }\n println(array[0]);\n}\n```\nIt prints 3 as the final refcount in `main`, because of how `maybe_mut` looks like:\n\n```rust\nbrillig(inline) fn maybe_mut f1 {\n b0(v0: [Field; 3], v1: u1):\n inc_rc v0\n v2 = allocate -> &mut [Field; 3]\n store v0 at v2\n jmpif v1 then: b1, else: b2\n b1():\n v3 = load v2 -> [Field; 3]\n v6 = array_set v3, index u32 0, value Field 4\n store v6 at v2\n jmp b2()\n b2():\n v7 = load v2 -> [Field; 3]\n v8 = array_get v7, index u32 0 -> Field\n call f2(v8)\n return\n}\n```\n\n</details>\n\nDoes your proposal address the speculative nature of `inc_rc`? As it stands it's primary goal is to prevent against accidental modification, at the cost of doing more copies\n\nI wonder if we could have a concept of `drop`, that is to understand when a reference goes out of scope, and decrement the RC at that point, and increment at the point where a borrow is made. For example I see `maybe_mut` emits an `inc_rc` because there is a possibility of mutation, while `borrow` in the test does not. Now, if I change `borrow` to _return_ the array it borrowed then it still doesn't increase the count, but the caller does on the returned value. Then, if I change it to return a struct wrapping the array, then both `borrow` and the caller increases the RC, with the two consecutive increments later being deduplicated. By contrast, we could increment the RC where in the caller when it passes an array to its callee, and decrement it if/when that reference is finally dropped, whether at the end of the called function, or when the returned structure wrapping it goes out of scope. So we would make simpler-to understand rules about inserting them, and perform the optimisation to remove them later, once we have the full picture. I can imagine identifying when a value is dropped is not trivial, though.\n\n(The deduplication of increments is a counter example for where my assumption that observable side effects - the printing of the ref count in this instance - should be the same between the initial and final SSA breaks down).\n> But where the inc_rc and dec_rc are inserted into the SSA will remain a source of speculation about how the array is going to be used, as it is now.\n\nNo, this proposal is to remove `inc_rc` and `dec_rc`\n\n> I wonder if we could have a concept of drop, \n\nI've considered trying to track when the arrays may be dropped in the past but as soon as the array gets stored in a mutable reference - which is the case with most arrays being mutated anyway - we lose almost all ability to track them since we'd have to delegate to mem2reg. You could also say we do have a drop of sorts since we do issue some `dec_rc` instructions, just only where we \"know\" a value won't be used afterward, e.g. an array parameter at the end of a function where no values containing arrays are returned. (\"know\" is in quotes due to the negative RC issue - clearly some assumptions are incorrect).\n\n> (The deduplication of increments is a counter example for where my assumption that observable side effects - the printing of the ref count in this instance - should be the same between the initial and final SSA breaks down).\n\n`can_be_deduplicated` should be `false` for both `inc_rc` and `dec_rc` so we shouldn't be deduplicating these instructions. We may deduplicate a constant `make_array` though - in which case we should add an extra `inc_rc`.\n\n> we shouldn't be deduplicating these instructions.\n\nThe deduplication of consecutive RC instructions happens [here](https://github.com/noir-lang/noir/blob/25b989fe5c2a247f66cefe09587526570ce7d71a/compiler/noirc_evaluator/src/ssa/opt/die.rs#L658-L665), `can_be_deduplicated` is not involved, it's a special case. \n\n> we do issue some dec_rc instructions, just only where we \"know\" a value won't be used afterward, e.g. an array parameter at the end of a function where no values containing arrays are returned. \n\nAs another example of why it's difficult to handle this in SSA when the RC is also in the hands of the Brillig VM, here's the SSA of such a function from my experiment:\n\n```\n v11 = load v4 -> [Field; 3]\n inc_rc v11\n ...\n v18 = load v4 -> [Field; 3]\n v20 = array_set v18, index u32 0, value Field 6\n store v20 at v4\n v21 = load v4 -> [Field; 3]\n dec_rc v21\n```\nSo it originally inserted an `inc_rc` and a `dec_rc` acting on the input `v4` (one of the `array: &mut [Field; 3]` parameters). What it can't know, is that `v20` may be a new array (I suppose it could, because after an `inc_rc` it will be, but in general I assume it doesn't), and that after `store v20 at v4` overwrites `v4` with this new array, `dec_rc v21` acting on a freshly loaded reference from `v4` will potentially act on an array different from what the original `inc_rc` was issued for. \n\n> No, this proposal is to remove inc_rc and dec_rc\n\nThanks for making that clear. I feared that for the same reason as above, if `dec_rc` was acting on a tuple member instead of the array it would be susceptible to fall victim of the same gotchas with forwarding rules and act on the values made by the copy-on-write procedure than the original. \nFor the record, the RC rules that would make more sense to me would be along the following lines:\n* Generally the caller should make the increment when they pass a borrowed value to a function, rather than the callee guessing whether to inc or not\n* `fn borrow(array: [Field; 3]`: the caller should increment the RC before passing `array`, and at the end of the method it can be dropped because it goes out of scope and doesn't get stored\n* `fn borrow_mut(array: &mut [Field; 3]`: unlike `borrow` I would not consider this an additional reference, just use _write_ semantics and modify the original without increasing the RC\n* `fn copy_mut(mut array: [Field; 3]`: the caller should increment the RC because it's a borrow and _copy-on-write_ should be used\n* `fn borrow_mut_two(array1: &mut [Field; 3], array2: &mut [Field; 3]`: like `borrow_mut`, I would argue that the RC should _not_ be increased at all (currently it increases it once for array2). That's because we want _write_ semantics and it should be the users' responsibility whether they pass reference to the same array or not, I don't think copies should be made unless there are other borrows such as `borrow` and `copy_mut` do, which imply _copy-on-write_. The effect of writing to the original seems to be the same anyway.\n\nThen we could let the SSA figure out which inc/dec pairs it can get rid of for optimisation, but it would make it clear when the RC is increased and why. \n\nReturning the array or storing it in a data structure should cancel the decrement.\n\nIs this 🌈 and 🦄 thinking?\nOne more observation about placing the `dec_rc` at the end is that the Brillig VM also modifies the RC of the original array during the copy procedure [here](https://github.com/noir-lang/noir/blob/25b989fe5c2a247f66cefe09587526570ce7d71a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/array_copy.rs#L72-L73), so these two alone can end up bringing the RC to zero:\n\n* if the final `dec_rc` acts on the original array after a copy was made, it's double decrementing\n* if the final `dec_rc` acts on the copy of the array, it's bringing it from 1 to 0 immediately\n* the final `dec_rc` should act on the original array, and only if no copy ended up being made\n\nThis might be fixed by https://github.com/noir-lang/noir/pull/7297#issuecomment-2640467338\n\n\n> Is this 🌈 and 🦄 thinking?\n\nNot necessarily but there are a couple of issues / practical concerns. The scheme you gave is more or less how they're intended to behave but have been changed over time as we were pressured to create smaller brillig bytecode sizes. Increasing the ref counts on each immutable function was leading to a bytecode explosion since it happens much more often and we cannot usually optimize out these cases. A related issue is that Noir doesn't have the concept of an immutable borrow which would normally be the case you'd keep the ref count the same - where a conceptual clone like we'd have where you pass by value you do normally increase it.\n\nSo we wanted to change where ref counts are to find places where less of them were needed and they were easier to optimize out. That's why we have both inc & dec within a function since then it is easier to identify when we can remove them as a pair. Versus if we had the inc outside the function we can't do that unless the function is inlined.\n\n> Returning the array or storing it in a data structure should cancel the decrement.\n\nHow do you know if the array was returned or stored in a data structure (and returned)? Usually references are involved so you won't know if the array in this reference is the same or not. Our answer for this currently is to say if the function returns any types containing an array of the same type then we have to pessimistically assume the array in question may be returned. This should lead to counts drifting up, not down, but I point it out as something to keep in mind that we probably can't be perfect here.\n\nAnyways - this was mostly to explain why we have our current system / how we got here since I think once you know that its easier to make changes to fix it or tear it down if necessary.\n\nEDIT: Clarification on why we increment on mutable values currently. In the current scheme to minimize unnecessary inc/decs we:\n- Assume all array values are passed as immutable references by default.\n- Only when the array is taken by mutable value, copied into a let binding, or into multiple `&mut` references do we increase the ref count. This is so if you have a deeply nested series of functions with one mutation deep in the call stack, that we don't need to inc/dec the rc for every function in between.\nAh, some details I left out from our current scheme:\n- Noir has no concept of moves so we approximate by incrementing ref count where an array may be copied. This is wherever a new variable binding may introduce an alias to the array. So let bindings and function parameters.\n> The deduplication of consecutive RC instructions happens [here](https://github.com/noir-lang/noir/blob/25b989fe5c2a247f66cefe09587526570ce7d71a/compiler/noirc_evaluator/src/ssa/opt/die.rs#L658-L665), can_be_deduplicated is not involved, it's a special case.\n\nHonestly, I don't see the correctness argument for that optimization - I think we should remove it entirely. Especially since counts are underflowing, one reason could be that these extra inc_rcs are required.\n\n> As another example of why it's difficult to handle this in SSA when the RC is also in the hands of the Brillig VM, here's the SSA of such a function from my experiment:\n> \n> v11 = load v4 -> [Field; 3]\n> inc_rc v11\n> ...\n> v18 = load v4 -> [Field; 3]\n> v20 = array_set v18, index u32 0, value Field 6\n> store v20 at v4\n> v21 = load v4 -> [Field; 3]\n> dec_rc v21\n\nYeah, this seems bad. It makes me think that we need a larger redesign as well since right not trying to fix it up seems to me like it'd just be \"garbage in, garbage out.\"\n\n**Move & Copy Elision Optimization scheme**\n\nI think going forward for more confidence in correctness & still having some optimizations we could:\n- Start with a scheme we have more confidence to be correct e.g. the one you described where we don't increment rc for references but do for passing by value.\n- Remove existing optimizations on ref counts. We won't need them.\n- Add an analysis to determine where an array is moved versus where it needs to be copied. This will need to be done before we issue inc/decs so before ssa-gen. We should issue explicit `clone(array)` IR nodes at this point (which probably just inc_rc internally).\n- Add an analysis to try to figure out which functions can immutably borrow an array (or just add immutable borrows to the language) so that those functions will not need to conceptually clone the array (inc_rc) either. This could be part of the previous pass since otherwise their ordering would be important since the move pass may issue a copy for a function that later turned out could have immutably borrowed the array. Note that an immutable borrow analysis will have to be conservative. If we have a function like `fn foo(a: [Field; 1], b: &mut [Field; 1])` we have to assume `a` and `b` could refer to the same array so `a` still can't be borrowed even if never mutated.\nSounds good! \n\n> since right not trying to fix it up seems to me like it'd just be \"garbage in, garbage out.\"\n\nI hope that this particular issue will be fixed by https://github.com/noir-lang/noir/pull/7297\n**Expose immutable references directly scheme**\n\nSpoke with @michaeljklein and @aakoshh and another option we're more strongly considering now is to add immutable references to Noir. If we do that:\n- Any by-value use of an array type would incur a copy\n- We would need to add a cloning operation to the language which would clone the array and unwrap it from the reference\n- Where arrays are cloned becomes a user's issue for optimizing their own code.\n- The compiler is simpler, we need fewer optimizations on RCs and testing on arrays becomes easier.\n- We could remove RCs entirely, copying every time a full array value is used as mentioned above, or keep rcs and just increase the reference count on a clone. This later case may be an easier transition but the compiler could still be copying unnecessarily since we'd still not be able to determine in all cases when to `dec_rc` if references are involved. For the always copy case above though, you could argue users still unnecessarily copy e.g. if using arrays in generics instead of array references in generics, although this could also be considered a user problem in that case.\n\nThis is something I'd support experimenting with. We would have to update libraries to take references where possible but could compare performance afterward.\n\n"},"commit_urls":{"kind":"list like","value":["https://github.com/noir-lang/noir/commit/12f65c014e9bb265e00efcf96a73ed25d59bd796","https://github.com/noir-lang/noir/commit/2562ef286f515319a3506a163ffe9704b0a1d7e4","https://github.com/noir-lang/noir/commit/aeff5d2d956331249e9583b8fda0c1900e294edc","https://github.com/noir-lang/noir/commit/582a40860e882f4d3d5f282a7eb3d3da83ca3d8f","https://github.com/noir-lang/noir/commit/2603d77fc58516d95b9666edbffeec58a6a20d61","https://github.com/noir-lang/noir/commit/f95014e0179700b1f0c68ec1cf7f9121df2585f5","https://github.com/noir-lang/noir/commit/8b4d38a3ebc68419619a3723309c56c67e1f3548","https://github.com/noir-lang/noir/commit/6b31a46ce694a38a3dab180304e0f8ceffdbdcc6","https://github.com/noir-lang/noir/commit/a8972389ed741c70d07add0b5d174d11df436190"],"string":"[\n \"https://github.com/noir-lang/noir/commit/12f65c014e9bb265e00efcf96a73ed25d59bd796\",\n \"https://github.com/noir-lang/noir/commit/2562ef286f515319a3506a163ffe9704b0a1d7e4\",\n \"https://github.com/noir-lang/noir/commit/aeff5d2d956331249e9583b8fda0c1900e294edc\",\n \"https://github.com/noir-lang/noir/commit/582a40860e882f4d3d5f282a7eb3d3da83ca3d8f\",\n \"https://github.com/noir-lang/noir/commit/2603d77fc58516d95b9666edbffeec58a6a20d61\",\n \"https://github.com/noir-lang/noir/commit/f95014e0179700b1f0c68ec1cf7f9121df2585f5\",\n \"https://github.com/noir-lang/noir/commit/8b4d38a3ebc68419619a3723309c56c67e1f3548\",\n \"https://github.com/noir-lang/noir/commit/6b31a46ce694a38a3dab180304e0f8ceffdbdcc6\",\n \"https://github.com/noir-lang/noir/commit/a8972389ed741c70d07add0b5d174d11df436190\"\n]","isConversational":false},"created_at":{"kind":"timestamp","value":"2025-04-15T19:23:12","string":"2025-04-15T19:23:12"},"version":{"kind":"string","value":"0.0"},"language":{"kind":"string","value":"Rust"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":2,"numItemsPerPage":100,"numTotalItems":1000,"offset":200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3ODEzMzk5OCwic3ViIjoiL2RhdGFzZXRzL2VybmllLXJlc2VhcmNoL01FbnZCZW5jaCIsImV4cCI6MTc3ODEzNzU5OCwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.fcYB2-Ny8MUHdcdZow4KxXFF1hTL49RRUuMH7ZQiWQ7_Ci4P58iN-bFnvmflGqDykejCxIlLAb3bdudtGPmMBA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":1000,"numBytesParquet":14463090}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
repo stringclasses 200
values | pull_number int64 13 143k | instance_id stringlengths 12 47 | issue_numbers listlengths 1 7 | base_commit stringlengths 40 40 | patch stringlengths 354 98.3k | test_patch stringlengths 137 8.74M | problem_statement stringlengths 142 63.8k | hints_text stringlengths 2 70.5k | all_hints_text stringlengths 2 70.5k | commit_urls listlengths 1 119 | created_at timestamp[s]date 2015-04-16 11:31:38 2025-12-17 10:26:03 | version stringclasses 196
values | language stringclasses 10
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
mikro-orm/mikro-orm | 6,642 | mikro-orm__mikro-orm-6642 | [
5361,
6641
] | adc4bf682cd42ac83c71619f62029a86d48b31e1 | diff --git a/packages/core/src/decorators/Embedded.ts b/packages/core/src/decorators/Embedded.ts
index f78f7489acea..963c42ba5fa8 100644
--- a/packages/core/src/decorators/Embedded.ts
+++ b/packages/core/src/decorators/Embedded.ts
@@ -1,15 +1,16 @@
-import type { AnyEntity, EntityKey, EntityProperty } from '../typings'... | diff --git a/tests/features/embeddables/GH5361.test.ts b/tests/features/embeddables/GH5361.test.ts
new file mode 100644
index 000000000000..2accb5651e22
--- /dev/null
+++ b/tests/features/embeddables/GH5361.test.ts
@@ -0,0 +1,190 @@
+import {
+ Embeddable,
+ Embedded,
+ Entity,
+ EntitySchema,
+ IntegerType,
+ Mi... | Add support for Embedded column name
**Is your feature request related to a problem? Please describe.**
Currently it is possible to define the name of a column to be different from the name of the ts/js field
```ts
@Property({ name: 'n' })
name!: string;
```
It is also possible to define an embedded object
... | Hmm I would say this should be already working.
Maybe I'm not looking at the right place but this is the definition for `EmbeddedOptions`:
```ts
export type EmbeddedOptions = {
entity?: string | (() => AnyEntity | AnyEntity[]);
type?: string;
prefix?: string | boolean;
nullable?: boolean;
obj... | Hmm I would say this should be already working.
Maybe I'm not looking at the right place but this is the definition for `EmbeddedOptions`:
```ts
export type EmbeddedOptions = {
entity?: string | (() => AnyEntity | AnyEntity[]);
type?: string;
prefix?: string | boolean;
nullable?: boolean;
obj... | [
"https://github.com/mikro-orm/mikro-orm/commit/f18c88fe761f536cbf8d14b417bab0c06a973374"
] | 2025-05-06T16:37:43 | 0.0 | TypeScript |
mikro-orm/mikro-orm | 6,053 | mikro-orm__mikro-orm-6053 | [
6031,
6502,
6503
] | 612d47dc4d2c6b3cb6243f2b869f3e57c4d5567f | diff --git a/packages/core/src/EntityManager.ts b/packages/core/src/EntityManager.ts
index 6388ed516581..0ed9253bdecb 100644
--- a/packages/core/src/EntityManager.ts
+++ b/packages/core/src/EntityManager.ts
@@ -1959,6 +1959,13 @@ export class EntityManager<Driver extends IDatabaseDriver = IDatabaseDriver> {
return... | diff --git a/tests/features/dataloader/GH6031.test.ts b/tests/features/dataloader/GH6031.test.ts
index 206a4063dba4..500da02e367d 100644
--- a/tests/features/dataloader/GH6031.test.ts
+++ b/tests/features/dataloader/GH6031.test.ts
@@ -1,14 +1,7 @@
-import {
- Collection,
- Entity,
- ManyToMany,
- MikroORM,
- Prima... | Dataloader failure with ManyToMany relationship
### Describe the bug
With a simple many to many relationship on an entity like this:
```
@ManyToMany(() => Country)
countries = new Collection<Country>(this);
```
Enabling dataloader to load this collection with e.g. `await user.countries.load({dataloader: ... | The problem is specifically a unidirectional M:N relation, if you add the inverse side it works fine.
@darkbasic could you look into this please?
> The problem is specifically a unidirectional M:N relation, if you add the inverse side it works fine
I think that's exactly what's going on. I will further look into ... | The problem is specifically a unidirectional M:N relation, if you add the inverse side it works fine.
@darkbasic could you look into this please?
> The problem is specifically a unidirectional M:N relation, if you add the inverse side it works fine
I think that's exactly what's going on. I will further look into ... | [
"https://github.com/mikro-orm/mikro-orm/commit/9361e77baa31ee5398637a2050975fd84fb07477",
"https://github.com/mikro-orm/mikro-orm/commit/5780829780448e135286e26a86076cca5ea03823",
"https://github.com/mikro-orm/mikro-orm/commit/6f3aa323a860804fc7bcb8a9602b2bd9b6cb1a26",
"https://github.com/mikro-orm/mikro-orm/... | 2024-09-22T11:22:00 | 0.0 | TypeScript |
mikro-orm/mikro-orm | 4,872 | mikro-orm__mikro-orm-4872 | [
4868
] | e27e4b907154933feba985badd4f6a60dee06317 | diff --git a/packages/core/src/EntityManager.ts b/packages/core/src/EntityManager.ts
index c2d3a991fda2..4604654b7dd1 100644
--- a/packages/core/src/EntityManager.ts
+++ b/packages/core/src/EntityManager.ts
@@ -710,6 +710,7 @@ export class EntityManager<D extends IDatabaseDriver = IDatabaseDriver> {
fields: re... | diff --git a/tests/features/read-replicas.test.ts b/tests/features/read-replicas.test.ts
index 95df66a1232c..da511cd18b23 100644
--- a/tests/features/read-replicas.test.ts
+++ b/tests/features/read-replicas.test.ts
@@ -123,6 +123,20 @@ describe('read-replicas', () => {
expect(mock.mock.calls[7][0]).toMatch(/begi... | upsert is using read replica for select
**Describe the bug**
When using `em.upsert()` with read replicas and `preferReadReplicas: true`. The select query that follows the insert query uses the read connections. Probably due to replication lag the hydration fails. I tried setting `preferReadReplicas: false` and it work... | I tried to debug it, and it works as expected when I add.` connectionType: 'write'` [here](https://github.com/mikro-orm/mikro-orm/blob/22e140e986420105c1b5941aae92a7bca1be6fef/packages/core/src/EntityManager.ts#L710-L712), but I am not sure if this is the right fix.
Yes, that place looks good, also the same will need t... | I tried to debug it, and it works as expected when I add.` connectionType: 'write'` [here](https://github.com/mikro-orm/mikro-orm/blob/22e140e986420105c1b5941aae92a7bca1be6fef/packages/core/src/EntityManager.ts#L710-L712), but I am not sure if this is the right fix.
Yes, that place looks good, also the same will need t... | [
"https://github.com/mikro-orm/mikro-orm/commit/8ce03354f0e4fee917f822db1f2ac8ac98c74228",
"https://github.com/mikro-orm/mikro-orm/commit/c47e2b76e7a8dc3f032ff84077c94547a0cdd474"
] | 2023-10-23T16:56:01 | 0.0 | TypeScript |
mikro-orm/mikro-orm | 6,186 | mikro-orm__mikro-orm-6186 | [
6179
] | 2e1621c89c208b483f7e3d4a8d22a9622ed697dd | diff --git a/packages/core/src/serialization/EntitySerializer.ts b/packages/core/src/serialization/EntitySerializer.ts
index 936d83531a36..8349abd8cf88 100644
--- a/packages/core/src/serialization/EntitySerializer.ts
+++ b/packages/core/src/serialization/EntitySerializer.ts
@@ -8,6 +8,7 @@ import type {
EntityDTOPro... | diff --git a/tests/features/custom-types/GH6179.test.ts b/tests/features/custom-types/GH6179.test.ts
new file mode 100644
index 000000000000..9fc1be7203cb
--- /dev/null
+++ b/tests/features/custom-types/GH6179.test.ts
@@ -0,0 +1,72 @@
+import { MikroORM, serialize, wrap } from '@mikro-orm/better-sqlite';
+
+import { En... | Serialization with forceObject: true does not apply primary key custom type
### Describe the bug
Serialization using `forceObject: true` doesn't apply custom type on foreign key.
### Reproduction
```ts
import { MikroORM, serialize, Entity, ManyToOne, Platform, PrimaryKey, Property, Ref, Type } from '@mikro... | Note that this has nothing to do with `forceObject`.
I've simplified your repro and inlined it here to the issue description.
I've submitted a new [PR](https://github.com/mikro-orm/mikro-orm/pull/6186) to fix this issue (tests pass but I don't have the bigger picture though on if it might have side-effects)
| [
"https://github.com/mikro-orm/mikro-orm/commit/0cca5319e838a6cc9d2aa9e3d458b17e26f8d11d",
"https://github.com/mikro-orm/mikro-orm/commit/98fda313117d18a9a508af7671cdcfd61bd6ceb2",
"https://github.com/mikro-orm/mikro-orm/commit/2e3b4771f123ab359f988cb7c5f314d6283f9394",
"https://github.com/mikro-orm/mikro-orm/... | 2024-10-23T13:53:17 | 0.0 | TypeScript | |
mikro-orm/mikro-orm | 6,902 | mikro-orm__mikro-orm-6902 | [
6885
] | 467e31ff8c0eb7c95342d1b0e60ccb7305908681 | diff --git a/packages/core/src/hydration/ObjectHydrator.ts b/packages/core/src/hydration/ObjectHydrator.ts
index 587c8993f2f9..5f62e27964ee 100644
--- a/packages/core/src/hydration/ObjectHydrator.ts
+++ b/packages/core/src/hydration/ObjectHydrator.ts
@@ -89,7 +89,13 @@ export class ObjectHydrator extends Hydrator {
... | diff --git a/tests/features/lazy-scalar-properties/GH6885.test.ts b/tests/features/lazy-scalar-properties/GH6885.test.ts
new file mode 100644
index 000000000000..cf3f5c56a228
--- /dev/null
+++ b/tests/features/lazy-scalar-properties/GH6885.test.ts
@@ -0,0 +1,176 @@
+import {
+ MikroORM,
+ Entity,
+ Property,
+ Prim... | Lazy property with nullable ScalarRef does not initialize when value is `null`
### Describe the bug
When attempting to use a lazy scalar reference that can possibly be nullable, calling `load()` or attempting to populate the field does not initialize the field and results in `undefined` if the resolved value is `null`.... | In investigation, I'm wondering if the issue is here? https://github.com/mikro-orm/mikro-orm/blob/467e31ff8c0eb7c95342d1b0e60ccb7305908681/packages/core/src/hydration/ObjectHydrator.ts#L144-L149
If the value is `null`, then this check fails and re-assigns the value to being an uninitialized ScalarReference. However, I... | In investigation, I'm wondering if the issue is here? https://github.com/mikro-orm/mikro-orm/blob/467e31ff8c0eb7c95342d1b0e60ccb7305908681/packages/core/src/hydration/ObjectHydrator.ts#L144-L149
If the value is `null`, then this check fails and re-assigns the value to being an uninitialized ScalarReference. However, I... | [
"https://github.com/mikro-orm/mikro-orm/commit/af2975cd035059c775b1f1fa3b6acb05d0d00d0d",
"https://github.com/mikro-orm/mikro-orm/commit/1fe6c28811fc03296f8be50dbde105df8928e095",
"https://github.com/mikro-orm/mikro-orm/commit/edd0fcedea431c1e0629176186f64fc634101157",
"https://github.com/mikro-orm/mikro-orm/... | 2025-10-02T17:21:34 | 0.0 | TypeScript |
wevm/viem | 635 | wevm__viem-635 | [
634
] | 2695f0d26de3331e7fc259071034c7560cca3f1d | diff --git a/src/utils/unit/parseUnits.ts b/src/utils/unit/parseUnits.ts
index 5b07a386a2..2accc74dd2 100644
--- a/src/utils/unit/parseUnits.ts
+++ b/src/utils/unit/parseUnits.ts
@@ -17,7 +17,7 @@ export function parseUnits(value: `${number}`, decimals: number) {
fraction.slice(decimals),
]
fraction = ... | diff --git a/src/utils/unit/parseUnits.test.ts b/src/utils/unit/parseUnits.test.ts
index f5951e2787..218c96c15a 100644
--- a/src/utils/unit/parseUnits.test.ts
+++ b/src/utils/unit/parseUnits.test.ts
@@ -9,10 +9,14 @@ test('converts number to unit of a given length', () => {
expect(parseUnits('20', 9)).toMatchInlineS... | bug: `parseUnits` strips leading zero's of the factional causing wrong results
### Is there an existing issue for this?
- [X] I have searched the existing issues
### Package Version
0.3.43
### Current Behavior
`parseUnits("630.0056882018259", 6)` results in `6305688n`
### Expected Behavior
`parseUnits("630.0... | Thanks! Fixed in `0.3.49`.
Hey, seems like the error was reintroduced ? I'm on `"viem": "^1.0.2"` and running:
```js
const decimal = 1.0536059576998882;
const bn = Number(parseUnits(`${decimal}`, 7));
console.log(decimal);
console.log(bn);
console.log(bn / 1e7);
```
outputs:
```
1.0536059576998882
1536060
0... | [
"https://github.com/wevm/viem/commit/b79eaa6a6563e33f67cd352b108a3f2ef260b119"
] | 2023-06-01T21:07:00 | 1.0 | TypeScript | |
wevm/viem | 383 | wevm__viem-383 | [
382
] | d19791425aac446651467c73a8b2273584892b86 | diff --git a/.changeset/two-ties-sort.md b/.changeset/two-ties-sort.md
new file mode 100644
index 0000000000..e5292d7b0c
--- /dev/null
+++ b/.changeset/two-ties-sort.md
@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Fixed an issue where `serializeTransaction` was incorrectly encoding zero-ish properties.
diff --git a/src/... | diff --git a/src/utils/transaction/serializeTransaction.test.ts b/src/utils/transaction/serializeTransaction.test.ts
index a1202e886c..0a1a49afac 100644
--- a/src/utils/transaction/serializeTransaction.test.ts
+++ b/src/utils/transaction/serializeTransaction.test.ts
@@ -41,6 +41,28 @@ describe('eip1559', () => {
}... | bug: Unable to send transaction with 0 as nonce
### Is there an existing issue for this?
- [X] I have searched the existing issues
### Package Version
0.3.2
### Current Behavior
When using a newly created privateKey with funds directly sent to it using a faucet, I'm unable to send any transaction due to ... | After a bit a digging, looks like if I force `nonce` to be `undefined` instead of `0` in a custom account the transaction will work as expected. My guess is that it's related to something over there : https://github.com/wagmi-dev/viem/blob/630f9cc34e9618041a766ef3e5a110165accbf4a/src/utils/transaction/serializeTransact... | After a bit a digging, looks like if I force `nonce` to be `undefined` instead of `0` in a custom account the transaction will work as expected. My guess is that it's related to something over there : https://github.com/wagmi-dev/viem/blob/630f9cc34e9618041a766ef3e5a110165accbf4a/src/utils/transaction/serializeTransact... | [
"https://github.com/wevm/viem/commit/338e15c4fddc6c0dda604b1c1ff04236699a7a87",
"https://github.com/wevm/viem/commit/26b781b83d3c245ea6b09e972f14285bb5f2c544",
"https://github.com/wevm/viem/commit/4b70ac2cd805c573fffb517faa9368482a4d9abf",
"https://github.com/wevm/viem/commit/94b9f36918dac05e35671a35ef4e6a708... | 2023-04-17T16:23:49 | 1.0 | TypeScript |
wevm/viem | 1,657 | wevm__viem-1657 | [
1655
] | 038d8debd4c22f1bb16c6b6b9466e4886ede2f97 | diff --git a/.changeset/serious-drinks-hammer.md b/.changeset/serious-drinks-hammer.md
new file mode 100644
index 0000000000..e0eb71edc8
--- /dev/null
+++ b/.changeset/serious-drinks-hammer.md
@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Fixed `writeContract` `args` type inference.
diff --git a/src/actions/wallet/writeC... | diff --git a/src/actions/wallet/writeContract.test-d.ts b/src/actions/wallet/writeContract.test-d.ts
index 04115ced6a..4717d2301e 100644
--- a/src/actions/wallet/writeContract.test-d.ts
+++ b/src/actions/wallet/writeContract.test-d.ts
@@ -8,6 +8,7 @@ import { walletClientWithAccount } from '~test/src/utils.js'
import ... | bug: args typing regression
### Is there an existing issue for this?
- [X] I have searched the existing issues
### Package Version
2.0.3
### Current Behavior
since `2.0.0`, `args` property type is inferred to `unknown[]` instead of the correct type.
### Expected Behavior
`args` should be inferred to `[number]` i... | Will take a look. In addition, your minimal reproduction ABI doesn't have any payable or nonpayable functions.
@tmm good point. This is just an error in the example, it doesn’t infer types properly with write function either.
| Will take a look. In addition, your minimal reproduction ABI doesn't have any payable or nonpayable functions.
@tmm good point. This is just an error in the example, it doesn’t infer types properly with write function either.
This issue has been locked since it has been closed for more than 14 days.
If you found a con... | [
"https://github.com/wevm/viem/commit/30024e2cfcaf627e5b5394190bf1d1e96c824679",
"https://github.com/wevm/viem/commit/00961a54750172abf2051c2f2358b89539bfa510",
"https://github.com/wevm/viem/commit/ae1b5bc49b2ec8fd428395b14a95acc278f0c166"
] | 2024-01-08T20:32:04 | 1.0 | TypeScript |
wevm/viem | 1,339 | wevm__viem-1339 | [
1336
] | a9c14e40d7d23f1b18e1899ac252dafc2c4717e9 | diff --git a/.changeset/plenty-meals-visit.md b/.changeset/plenty-meals-visit.md
new file mode 100644
index 0000000000..462ae4137e
--- /dev/null
+++ b/.changeset/plenty-meals-visit.md
@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Fixed topics mismatch in `decodeEventLogs` strict mode.
diff --git a/src/utils/abi/decodeEve... | diff --git a/src/actions/public/getFilterChanges.test.ts b/src/actions/public/getFilterChanges.test.ts
index 67c0fe20cf..2aa6c4948d 100644
--- a/src/actions/public/getFilterChanges.test.ts
+++ b/src/actions/public/getFilterChanges.test.ts
@@ -356,7 +356,7 @@ describe('contract events', () => {
'Transfer'
... | decodeEventLog in strict: true mode fails to enforce ABI conformity on indexed arguments
### Is there an existing issue for this?
- [X] I have searched the existing issues
### Package Version
^1.15.1
### Current Behavior
I've encountered an issue where `decodeEventLog` when used with `strict: true` is no... | I might just misunderstand how indexed args are supposed to behave, in which case feel free to close :)
What’s your ABI?
NounsAuctionHouse https://etherscan.io/address/0xf15a943787014461d94da08ad4040f79cd7c124e#code
Nice catch! PR here: https://github.com/wagmi-dev/viem/pull/1339
| I might just misunderstand how indexed args are supposed to behave, in which case feel free to close :)
What’s your ABI?
NounsAuctionHouse https://etherscan.io/address/0xf15a943787014461d94da08ad4040f79cd7c124e#code
Nice catch! PR here: https://github.com/wagmi-dev/viem/pull/1339
This issue has been locked since it ha... | [
"https://github.com/wevm/viem/commit/80f50a4b96661a05d12ee985f76c3be26e257357",
"https://github.com/wevm/viem/commit/6271ebe9212a47d738a35cd25fca020e263275b6"
] | 2023-10-12T00:11:55 | 1.0 | TypeScript |
wevm/viem | 198 | wevm__viem-198 | [
180,
197
] | b9778b0d29b81654e6741a014c0b2213c6f34587 | diff --git a/.changeset/warm-jokes-dress.md b/.changeset/warm-jokes-dress.md
new file mode 100644
index 0000000000..364d1aaeca
--- /dev/null
+++ b/.changeset/warm-jokes-dress.md
@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Added an assertion in `decodeEventLog` to check for a mismatch between topics + indexed event para... | diff --git a/src/errors/abi.test.ts b/src/errors/abi.test.ts
index db20149920..38dfb5d8a3 100644
--- a/src/errors/abi.test.ts
+++ b/src/errors/abi.test.ts
@@ -1,8 +1,9 @@
-import { expect, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
import {
AbiDecodingDataSizeInvalidError,
AbiEncodingA... | bug: decodeEventLog topics type error when cycling getLogs data
### Is there an existing issue for this?
- [X] I have searched the existing issues
### Package Version
^0.1.7
### Current Behavior
> Type 'TopicFilter' is not assignable to type '[signature: `0x${string}`, ...args: LogTopic[]]'.
Source provides no ... | Related [discussion](https://github.com/wagmi-dev/viem/discussions/163) and [PR](https://github.com/wagmi-dev/viem/pull/178).
It may not make sense for `decodeEventLog` to require the first element of the `topics` array to be a `Hex`, because anonymous events with no indexed parameters have `topics == []`.
Relate... | Related [discussion](https://github.com/wagmi-dev/viem/discussions/163) and [PR](https://github.com/wagmi-dev/viem/pull/178).
It may not make sense for `decodeEventLog` to require the first element of the `topics` array to be a `Hex`, because anonymous events with no indexed parameters have `topics == []`.
Relate... | [
"https://github.com/wevm/viem/commit/36bb33f01cbdc467fd2f871a2527db282a4e9e48",
"https://github.com/wevm/viem/commit/1b7a815658e2e9cb21cd03c8a131c0deab5caf20",
"https://github.com/wevm/viem/commit/07071cd7b3e88d61e25da73605fdf46b4f026488"
] | 2023-03-12T19:25:19 | 1.0 | TypeScript |
honojs/hono | 4,423 | honojs__hono-4423 | [
4196
] | 393ded96196da1b4f23813fea670b0d5a70526c6 | diff --git a/src/helper/route/index.ts b/src/helper/route/index.ts
index bffebe28f..1587f630e 100644
--- a/src/helper/route/index.ts
+++ b/src/helper/route/index.ts
@@ -37,23 +37,32 @@ export const matchedRoutes = (c: Context): RouterRoute[] =>
* Get the route path registered within the handler
*
* @param {Contex... | diff --git a/src/helper/route/index.test.ts b/src/helper/route/index.test.ts
index 52e6f50d6..18106a784 100644
--- a/src/helper/route/index.test.ts
+++ b/src/helper/route/index.test.ts
@@ -63,6 +63,11 @@ describe('routePath', () => {
expect(routePath(c)).toBe('/:id')
+ expect(routePath(c, 0)).toBe('/:id')
+... | Support get real route path in middleware
### What is the feature you are proposing?
Now
```ts
app.use(async (c, next) => {
console.log(c.req.method, c.req.routePath, c.req.path, c.req.url)
// GET /* /user/1 http://127.0.0.1:3000/user/1
}
app.get("/user/:id", ...)
// an... | Hi @seepine
Now, you can use Route helper: https://hono.dev/docs/helpers/route
```ts
import { Hono } from 'hono'
import { routePath } from 'hono/route'
const app = new Hono()
app.get('/user/:id', (c) => {
console.log(routePath(c)) // `/user/:id`
return c.json({})
})
export default app
```
@yusukebe Hi, i want... | Hi @seepine
Now, you can use Route helper: https://hono.dev/docs/helpers/route
```ts
import { Hono } from 'hono'
import { routePath } from 'hono/route'
const app = new Hono()
app.get('/user/:id', (c) => {
console.log(routePath(c)) // `/user/:id`
return c.json({})
})
export default app
```
@yusukebe Hi, i want... | [
"https://github.com/honojs/hono/commit/34bb026c0916d8bf0e64c803da2ac56dfb6a8e42"
] | 2025-09-23T01:06:40 | 1.6 | TypeScript |
honojs/hono | 1,715 | honojs__hono-1715 | [
1713
] | 1ed742bdb80518437e6d6f9c6ec7a5fbe300f254 | diff --git a/deno_dist/hono-base.ts b/deno_dist/hono-base.ts
index 6a356d960..5cfc267c0 100644
--- a/deno_dist/hono-base.ts
+++ b/deno_dist/hono-base.ts
@@ -279,7 +279,7 @@ class Hono<
const path = this.getPath(request, { env })
const [handlers, paramStash] = this.matchRoute(method, path)
- const c = new... | diff --git a/src/hono.test.ts b/src/hono.test.ts
index 29b15cc71..8fe95d2f1 100644
--- a/src/hono.test.ts
+++ b/src/hono.test.ts
@@ -659,6 +659,12 @@ describe('param and query', () => {
expect(await res.text()).toBe('id is 123')
})
+ it('param of /entry/:id is found, even for Array object method names'... | Param value of "keys" resolves to a function, not the value "keys"
### What version of Hono are you using?
3.10.1
### What runtime/platform is your app running on?
Node, Cloudflare Workers
### What steps can reproduce the bug?
Create a Hono app with multiple nested routes:
```ts
// Adapted from Hono'... | I have [a fork](https://github.com/AverageHelper/hono/tree/avg/param-keys) where I've already added a failing test as described.
The issue seems primarily to occur in src/request.ts:56: https://github.com/honojs/hono/blob/1ed742bdb80518437e6d6f9c6ec7a5fbe300f254/src/request.ts#L56
In the failing case, `this._s` i... | I have [a fork](https://github.com/AverageHelper/hono/tree/avg/param-keys) where I've already added a failing test as described.
The issue seems primarily to occur in src/request.ts:56: https://github.com/honojs/hono/blob/1ed742bdb80518437e6d6f9c6ec7a5fbe300f254/src/request.ts#L56
In the failing case, `this._s` i... | [
"https://github.com/honojs/hono/commit/f9146dedfcba64114dbba5522a1b0688781379d4",
"https://github.com/honojs/hono/commit/cdb95ea3c30aa1516aef922a658c5cc9fb34f71a",
"https://github.com/honojs/hono/commit/02ec456b0c957aabd1bfc0674839cc3daac34a4b",
"https://github.com/honojs/hono/commit/38169ea43d278a57aa4bdb0a8... | 2023-11-16T21:29:28 | 1.6 | TypeScript |
honojs/hono | 2,122 | honojs__hono-2122 | [
2100
] | 60e85b31cf1024e27a2d6421041d279e0f3db305 | diff --git a/deno_dist/types.ts b/deno_dist/types.ts
index 03c64f892..3c7c4b1a1 100644
--- a/deno_dist/types.ts
+++ b/deno_dist/types.ts
@@ -3,7 +3,7 @@
/* eslint-disable @typescript-eslint/ban-types */
import type { Context } from './context.ts'
import type { Hono } from './hono.ts'
-import type { IntersectNonAnyTy... | diff --git a/src/types.test.ts b/src/types.test.ts
index ea9247b48..a6a81412a 100644
--- a/src/types.test.ts
+++ b/src/types.test.ts
@@ -525,7 +525,6 @@ describe('merge path', () => {
message: string
}
}
- } & {
$get: {
input: {}
output: {
@@ -557,6 +... | Path params are not inferred correctly
### What version of Hono are you using?
3.12.7
### What runtime/platform is your app running on?
Bun
### What steps can reproduce the bug?
```ts
import { Hono } from 'hono';
import { hc } from 'hono/client';
const app1 = new Hono().get('/c/:d', async (c) => c.json({ mess... | Hi @siriscmv
Thanks for raising the issue. This is a bug. I'll fix it later.
| Hi @siriscmv
Thanks for raising the issue. This is a bug. I'll fix it later.
| [
"https://github.com/honojs/hono/commit/b27868c54ee6eef71ff75cdc1eaa31dcb490f6e5",
"https://github.com/honojs/hono/commit/a86f1231b6a3ff0294e1192246b50683a141b58a",
"https://github.com/honojs/hono/commit/7e81ea1713790967e919154c801da3dbc4a92c19",
"https://github.com/honojs/hono/commit/31eded145682d316a02aa5527... | 2024-01-30T23:13:47 | 1.6 | TypeScript |
honojs/hono | 1,769 | honojs__hono-1769 | [
1766
] | bd00d284693e2079bb3be7ee762bcde53b194c73 | diff --git a/deno_dist/client/types.ts b/deno_dist/client/types.ts
index afc517a9e..24128dc6f 100644
--- a/deno_dist/client/types.ts
+++ b/deno_dist/client/types.ts
@@ -26,11 +26,7 @@ type ClientRequest<S extends Schema> = {
$url: () => URL
}
-type BlankRecordToNever<T> = T extends Record<infer R, unknown>
- ? R... | diff --git a/src/client/client.test.ts b/src/client/client.test.ts
index e06b20a00..f02d3b0f9 100644
--- a/src/client/client.test.ts
+++ b/src/client/client.test.ts
@@ -5,7 +5,7 @@ import FormData from 'form-data'
import { rest } from 'msw'
import { setupServer } from 'msw/node'
import _fetch, { Request as NodeFetch... | ClientResponse.json() with possibly undefined values is always inferred as "never"
### What version of Hono are you using?
3.10.1
### What runtime/platform is your app running on?
Node / Browser
### What steps can reproduce the bug?
When ClientResponse.json() is called with a type that has an optional fi... | [
"https://github.com/honojs/hono/commit/4ca51ed1c7c5700d6861ee03acd0794015127c75",
"https://github.com/honojs/hono/commit/41867a085af38005e0e5bdb63f1fd69bcba8d8f4"
] | 2023-12-03T09:39:21 | 1.6 | TypeScript | ||
honojs/hono | 4,249 | honojs__hono-4249 | [
2175,
3088
] | 5149aa421bef92d3a495287f2f67bca4382bad39 | diff --git a/src/helper/ssg/middleware.ts b/src/helper/ssg/middleware.ts
index 0e4a4909c..e9684cb8d 100644
--- a/src/helper/ssg/middleware.ts
+++ b/src/helper/ssg/middleware.ts
@@ -1,5 +1,6 @@
import type { Context } from '../../context'
import type { Env, MiddlewareHandler } from '../../types'
+import { isDynamicRou... | diff --git a/src/helper/ssg/ssg.test.tsx b/src/helper/ssg/ssg.test.tsx
index 9af23e3df..67af8b863 100644
--- a/src/helper/ssg/ssg.test.tsx
+++ b/src/helper/ssg/ssg.test.tsx
@@ -955,3 +955,42 @@ describe('SSG Plugin System', () => {
)
})
})
+
+describe('ssgParams', () => {
+ it('should invoke callback only onc... | Invoke callback for `ssgParams()` only once
### What is the feature you are proposing?
Same issue as @nakasyou mentions below, but now `ssgParams()` is pure middleware and also not handling special skipping internally, so it is called many times during SSG.
https://github.com/honojs/hono/pull/2169#issuecomment-1934... | How about that?
@yusukebe @sor4chi @watany-dev @nakasyou
@usualoma
Hi!
Interesting approach. I'll take a look at the details later. But can you think of any other PSEUDO middleware?
@yusukebe
Hmmm no, there is no particular other use for PSEUDO middleware.
But I still don't think "send a request to the entire ro... | How about that?
@yusukebe @sor4chi @watany-dev @nakasyou
@usualoma
Hi!
Interesting approach. I'll take a look at the details later. But can you think of any other PSEUDO middleware?
@yusukebe
Hmmm no, there is no particular other use for PSEUDO middleware.
But I still don't think "send a request to the entire ro... | [
"https://github.com/honojs/hono/commit/bf8909eb3bee65320364a8906dbf6b000268a2e5",
"https://github.com/honojs/hono/commit/2d4579d5b8985a53a3bd2c5a82b03ebd00230f5b"
] | 2025-06-27T02:38:23 | 1.6 | TypeScript |
denoland/std | 3,310 | denoland__std-3310 | [
3223
] | c05ce92bf23cbfde1eb74111645a40a4326758a1 | diff --git a/encoding/ascii85.ts b/encoding/ascii85.ts
index 5487ee072625..45f680e6e787 100644
--- a/encoding/ascii85.ts
+++ b/encoding/ascii85.ts
@@ -76,7 +76,7 @@ export function encode(uint8: Uint8Array, options?: Ascii85Options): string {
uint8 = new Uint8Array(tmp.length + difference);
uint8.set(tmp);
... | diff --git a/encoding/ascii85_test.ts b/encoding/ascii85_test.ts
index 84255a3280c9..3af1b24a6c37 100644
--- a/encoding/ascii85_test.ts
+++ b/encoding/ascii85_test.ts
@@ -176,3 +176,19 @@ for (const [standard, tests] of Object.entries(testCasesDelimiter)) {
},
});
}
+
+Deno.test({
+ name: `[encoding/ascii85] ... | encoding/ascii85.ts: `encode()` returns a wrong result with a 4-byte subarray
#### Describe the bug
The `encode()` function from *encoding/ascii.ts* returns a wrong result with a subarray. More specifically, if a subarray is a 4-byte (or multiples of 4 bytes) slice of a buffer longer than it, and the slice refers ... | Probably the same issue that I've fixed here - https://github.com/denoland/deno_std/pull/3208
https://github.com/denoland/deno_std/blob/69fa1e956c2469f168756d757b1653323327ed53/encoding/ascii85.ts#L78-L79
Should be trivial to port the patch there with the appropriate test.
| Probably the same issue that I've fixed here - https://github.com/denoland/deno_std/pull/3208
https://github.com/denoland/deno_std/blob/69fa1e956c2469f168756d757b1653323327ed53/encoding/ascii85.ts#L78-L79
Should be trivial to port the patch there with the appropriate test.
| [
"https://github.com/denoland/std/commit/88d74458c02314ea32a285c03fc37dc7cbb55e98",
"https://github.com/denoland/std/commit/9055eda9b1e9726df86d48fa51b9f5a360e4bf6e",
"https://github.com/denoland/std/commit/cc0bae1749a3bf117c5e816c74235ddcd4d88ec6"
] | 2023-04-09T15:39:41 | 0.138 | TypeScript |
denoland/std | 6,378 | denoland__std-6378 | [
6374
] | b7c76d5d904dcdd307296d5ee5f5dd9a22771523 | diff --git a/cli/deno.json b/cli/deno.json
index aaab86bc67f4..f0a23aea24f5 100644
--- a/cli/deno.json
+++ b/cli/deno.json
@@ -5,6 +5,8 @@
".": "./mod.ts",
"./parse-args": "./parse_args.ts",
"./prompt-secret": "./prompt_secret.ts",
+ "./unstable-progress-bar": "./unstable_progress_bar.ts",
+ "./uns... | diff --git a/cli/unstable_progress_bar_stream_test.ts b/cli/unstable_progress_bar_stream_test.ts
new file mode 100644
index 000000000000..30be83b146d2
--- /dev/null
+++ b/cli/unstable_progress_bar_stream_test.ts
@@ -0,0 +1,42 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import { assertEquals } from "@st... | feat: `@std/cli` should have a progress bar function
The `@std/cli` has a spinner function to display the fact that something is loading, likewise we should also have a progress bar function that enables us to show the progress of something happening.
| I am in favour of adding this to std.
What should it look like by default and what should be customizable?
There are many different cli progress bar styles in cli land, some with, some without percentage and/or n/m displays, prefixes, suffixes etc.
`[####----------------]`, `[####----------------] 20%`, `[####---------... | I am in favour of adding this to std.
What should it look like by default and what should be customizable?
There are many different cli progress bar styles in cli land, some with, some without percentage and/or n/m displays, prefixes, suffixes etc.
`[####----------------]`, `[####----------------] 20%`, `[####---------... | [
"https://github.com/denoland/std/commit/2cf63a4a8dc3fe9a0d0a72a2d450a3621c47f690",
"https://github.com/denoland/std/commit/f77522d877bec016d7432a41025f577ebd4bac47",
"https://github.com/denoland/std/commit/24da78cc0776d0d615814be8dc115b6466627227",
"https://github.com/denoland/std/commit/252ff3ee1ef79b785f43e... | 2025-02-03T10:29:53 | 0.138 | TypeScript |
denoland/std | 5,173 | denoland__std-5173 | [
5177
] | b11514e21d120f736650a728e76fd7cf6cac6377 | diff --git a/json/deno.json b/json/deno.json
index 1738a5985775..6e48c342d71d 100644
--- a/json/deno.json
+++ b/json/deno.json
@@ -5,7 +5,7 @@
".": "./mod.ts",
"./types": "./types.ts",
"./concatenated-json-parse-stream": "./concatenated_json_parse_stream.ts",
- "./json-parse-stream": "./json_parse_str... | diff --git a/json/_test_utils.ts b/json/_test_utils.ts
index 1ee765f73359..75c0870aa45c 100644
--- a/json/_test_utils.ts
+++ b/json/_test_utils.ts
@@ -1,7 +1,7 @@
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
import { assertEquals, assertRejects } from "@std/assert";
import type { Concat... | proposal(json,csv): avoid repetition in entrypoint name if it has the same word as the pacakge name in the beginning
In addition to #5162, the core team suggests the below entrypoint name changes to make the rule more consistent across std.
- `std/csv/csv-parse-stream` -> `std/csv/parse-stream`
- `std/csv/csv-strin... | Should we also do the rename of `@std/json/concatenated-json-parse-stream` -> `@std/json/concatenated-parse-stream`?
context: https://github.com/denoland/deno_std/pull/5173#discussion_r1658192661
| [
"https://github.com/denoland/std/commit/438bf9a4e6150de5947471db3734f0b1d5e99575",
"https://github.com/denoland/std/commit/e2aca0d061f948e8309c2c79019b16a3a0b42771",
"https://github.com/denoland/std/commit/19b6056a5f4eb920256e6c11d223fc5e465d6cbd",
"https://github.com/denoland/std/commit/ac3faccd9b3ac4b27709e... | 2024-06-27T07:58:10 | 0.138 | TypeScript | |
denoland/std | 3,254 | denoland__std-3254 | [
3094
] | 3e98ac2b302ad0abfe683253bb97a36651439b27 | diff --git a/front_matter/mod.ts b/front_matter/mod.ts
index a634a4ff9f87..9a4ab94ca2d2 100644
--- a/front_matter/mod.ts
+++ b/front_matter/mod.ts
@@ -129,6 +129,13 @@
* = toml =
* ```
*
+ * ```markdown
+ * +++
+ * is = 'that'
+ * not = 'cool?'
+ * +++
+ * ```
+ *
* #### JSON
*
* ```markdown
@@ -175,6 +182,... | diff --git a/front_matter/_test_utils.ts b/front_matter/_test_utils.ts
index a498a43a3b19..ee3639ad5ba0 100644
--- a/front_matter/_test_utils.ts
+++ b/front_matter/_test_utils.ts
@@ -194,3 +194,31 @@ tags = ['toml', 'front-matter']
"with some ---toml 👌 crazy stuff in it",
);
}
+
+export async function runExtr... | TOML frontmatter extraction should look between +++ instead of ---
**Describe the bug**
**Steps to Reproduce**
extract TOML frontmatter from a hugo/zola blog post:
```
+++
title = "Title"
+++
Content
```
using https://deno.land/std@0.171.0/encoding/front_matter/toml.ts doen't extract the frontmatter at... | Is this convention common across tools? Or specific to Hugo?
It's definitely not in the spec (ref: https://github.com/toml-lang/toml/issues/511). I think that this is application-specific, but I honestly don't see a lot of tools that use toml front matter in general. I would be okay with changing it just because of Hug... | Is this convention common across tools? Or specific to Hugo?
It's definitely not in the spec (ref: https://github.com/toml-lang/toml/issues/511). I think that this is application-specific, but I honestly don't see a lot of tools that use toml front matter in general. I would be okay with changing it just because of Hug... | [
"https://github.com/denoland/std/commit/7c7f217c33f3e5057c40cd6a32211b7620ddad1d",
"https://github.com/denoland/std/commit/72da38088a926bd7677c37ebaa5e65b5749578b0",
"https://github.com/denoland/std/commit/47a62fcd095debb9466a6dfcae632b92d8077e9d"
] | 2023-03-14T15:39:12 | 0.138 | TypeScript |
denoland/std | 6,246 | denoland__std-6246 | [
4955
] | b2b7f9968305dd8436350da16d4236751cca74c1 | diff --git a/assert/not_equals.ts b/assert/not_equals.ts
index 10da792b814d..b87fd7dd0beb 100644
--- a/assert/not_equals.ts
+++ b/assert/not_equals.ts
@@ -3,6 +3,7 @@
import { equal } from "./equal.ts";
import { AssertionError } from "./assertion_error.ts";
+import { format } from "@std/internal/format";
/**
*... | diff --git a/assert/not_equals_test.ts b/assert/not_equals_test.ts
index c9e86bb1de1f..273748cf7791 100644
--- a/assert/not_equals_test.ts
+++ b/assert/not_equals_test.ts
@@ -17,7 +17,18 @@ Deno.test("assertNotEquals() throws", () => {
assertNotEquals("foo", "foo");
},
AssertionError,
- "Expected ac... | assertNotEquals assertion error message discrepancy
There is an issue with the `assertNotEquals` output int the current version of the library. The assertion error message does not reflect the expected string values accurately. Specifically, the following test case:
`assertNotEquals('1','1');`
is expected to thro... | I'm happy to add quotes to strings for this function. WDYT, @kt3k?
The suggestion makes sense to me. Maybe we should use `format` of `std/internal` to make the expression?
| I'm happy to add quotes to strings for this function. WDYT, @kt3k?
The suggestion makes sense to me. Maybe we should use `format` of `std/internal` to make the expression?
| [
"https://github.com/denoland/std/commit/fe8a641792ed9edc2466ef3f8609e9893efce7c8",
"https://github.com/denoland/std/commit/acb1c1f6e5b9acf913801dda874a6a1abe341e79"
] | 2024-12-09T08:55:11 | 0.138 | TypeScript |
adobe/spectrum-web-components | 3,392 | adobe__spectrum-web-components-3392 | [
3238
] | 98d03701b05101bae4a9e1f4d554bf0648979884 | diff --git a/.circleci/config.yml b/.circleci/config.yml
index 49b26d9dd4f..79856383a90 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -10,7 +10,7 @@ executors:
parameters:
current_golden_images_hash:
type: string
- default: 31192df5022fe2dfc067ca7b4c8d72b0d2d98510
+ defaul... | diff --git a/packages/picker/test/index.ts b/packages/picker/test/index.ts
index 55aa24004c8..1b689db5743 100644
--- a/packages/picker/test/index.ts
+++ b/packages/picker/test/index.ts
@@ -39,11 +39,19 @@ import {
findAccessibilityNode,
sendKeys,
} from '@web/test-runner-commands';
-import { iconsOnly } from... | [Bug][a11y]: Picker: VoiceOver fails to announce label in Chrome
### Code of conduct
- [X] I agree to follow this project's code of conduct.
### Impacted component(s)
Picker
### Expected behavior
The button element in the sp-picker component's shadow DOM is labeled internally using aria-labelledby:
1. ... | [
"https://github.com/adobe/spectrum-web-components/commit/218bf84a5fa36c18d37a1c53605fc481838ebf8a",
"https://github.com/adobe/spectrum-web-components/commit/8fef06a67eb1ac667920ec8db868ca941b550779"
] | 2023-06-29T12:15:14 | 0.0 | TypeScript | ||
adobe/spectrum-web-components | 4,494 | adobe__spectrum-web-components-4494 | [
4225
] | e1ef097bc4c4a1e888de028f40b6f2bb5ea2d7b8 | diff --git a/packages/progress-bar/src/ProgressBar.ts b/packages/progress-bar/src/ProgressBar.ts
index b9799764ff3..5eebbebf5ff 100644
--- a/packages/progress-bar/src/ProgressBar.ts
+++ b/packages/progress-bar/src/ProgressBar.ts
@@ -72,9 +72,8 @@ export class ProgressBar extends SizedMixin(
? html`
... | diff --git a/packages/progress-bar/test/progress-bar.test.ts b/packages/progress-bar/test/progress-bar.test.ts
index e7bb6755f28..9d7ee40be79 100644
--- a/packages/progress-bar/test/progress-bar.test.ts
+++ b/packages/progress-bar/test/progress-bar.test.ts
@@ -21,18 +21,14 @@ import { createLanguageContext } from '../.... | [Bug]: duplicate label in sp-progress-bar
### Code of conduct
- [X] I agree to follow this project's code of conduct.
### Impacted component(s)
sp-progress-bar, sp-field-label
### Expected behavior
An sp-progress-bar that is initially created with an undefined label, and later has a label defined, should display t... | [
"https://github.com/adobe/spectrum-web-components/commit/c48598f8d920ee1d883f8ac2710148eeb426ba19",
"https://github.com/adobe/spectrum-web-components/commit/3257a18819124584d60bf2cbe111bb89efb04bbb",
"https://github.com/adobe/spectrum-web-components/commit/fb42db12d3b6ffae8a48534c2f0642fca86dc4ec",
"https://g... | 2024-05-23T17:25:50 | 0.0 | TypeScript | ||
adobe/spectrum-web-components | 4,263 | adobe__spectrum-web-components-4263 | [
4201
] | 8b61b0aec9ee6ffd363809957b45a4a56650acd6 | diff --git a/packages/number-field/src/NumberField.ts b/packages/number-field/src/NumberField.ts
index a85afc41a2a..0c80f504704 100644
--- a/packages/number-field/src/NumberField.ts
+++ b/packages/number-field/src/NumberField.ts
@@ -495,7 +495,9 @@ export class NumberField extends TextfieldBase {
// Step shoul... | diff --git a/packages/number-field/test/inputs.test.ts b/packages/number-field/test/inputs.test.ts
index 940d7779433..d23f0dd2e2d 100644
--- a/packages/number-field/test/inputs.test.ts
+++ b/packages/number-field/test/inputs.test.ts
@@ -314,6 +314,27 @@ describe('NumberField - inputs', () => {
expect(el.va... | [Bug]: Editable Slider not rounding values
### Code of conduct
- [X] I agree to follow this project's code of conduct.
### Impacted component(s)
Slider
### Expected behavior
Editable Slider onChange `event.target.value` should print 0.56 after adding`0.55999999999` on the NumberField
### Actual beha... | Would this be considered a duplicate of #3817?
| Would this be considered a duplicate of #3817?
| [
"https://github.com/adobe/spectrum-web-components/commit/3f6fde40728d06763081714407fdde11b0647f56",
"https://github.com/adobe/spectrum-web-components/commit/c8a49bc648fa4fac2ceba415bedcb0e33b77ff9e",
"https://github.com/adobe/spectrum-web-components/commit/15bf1417c0f115b841fdca19422d7a7b2ec1e6a5",
"https://g... | 2024-04-12T05:39:00 | 0.0 | TypeScript |
adobe/spectrum-web-components | 4,155 | adobe__spectrum-web-components-4155 | [
3811
] | 9c9bf952cf2a1e4a0c5bc35e63e46f5d5bd6afe8 | diff --git a/packages/split-view/src/SplitView.ts b/packages/split-view/src/SplitView.ts
index 04776578aed..c39805e557b 100644
--- a/packages/split-view/src/SplitView.ts
+++ b/packages/split-view/src/SplitView.ts
@@ -184,8 +184,9 @@ export class SplitView extends SpectrumElement {
this.viewSize... | diff --git a/packages/split-view/test/split-view.test.ts b/packages/split-view/test/split-view.test.ts
index 8d36c4e2485..811f35f7524 100644
--- a/packages/split-view/test/split-view.test.ts
+++ b/packages/split-view/test/split-view.test.ts
@@ -972,6 +972,41 @@ describe('SplitView', () => {
expect(testPanel).t... | [split-view]: update label attribute to be customisable
### Code of conduct
- [X] I agree to follow this project's code of conduct.
### Description of issue
Follow up to the work done in https://github.com/adobe/spectrum-web-components/pull/3800
The `this.label` attribute in `sp-split-view` is inconsistent with ... | [
"https://github.com/adobe/spectrum-web-components/commit/e3317ccffdd2e9abfd727ddaba2a5dfa05d63a59"
] | 2024-03-07T22:15:54 | 0.0 | TypeScript | ||
adobe/spectrum-web-components | 4,933 | adobe__spectrum-web-components-4933 | [
3272
] | bb53e32ef16d239c3310b9a75c94eab06687ab21 | diff --git a/packages/number-field/src/NumberField.ts b/packages/number-field/src/NumberField.ts
index 447771ca3db..90d67581bad 100644
--- a/packages/number-field/src/NumberField.ts
+++ b/packages/number-field/src/NumberField.ts
@@ -747,7 +747,7 @@ export class NumberField extends TextfieldBase {
... | diff --git a/packages/number-field/test/number-field.test.ts b/packages/number-field/test/number-field.test.ts
index 1521027c9d0..333bca287f0 100644
--- a/packages/number-field/test/number-field.test.ts
+++ b/packages/number-field/test/number-field.test.ts
@@ -1753,7 +1753,7 @@ describe('NumberField', () => {
... | [Bug]: sp-number-field pressing increment/decrement buttons using NVDA moves focus to the text field
### Code of conduct
- [X] I agree to follow this project's code of conduct.
### Impacted component(s)
sp-number-field
### Expected behavior
When I press the increment or decrement buttons focus should stay on the b... | Related to #3274 #3271
| Related to #3274 #3271
| [
"https://github.com/adobe/spectrum-web-components/commit/e1515b8ece537a658b3e0e55da9b0042b20d2525",
"https://github.com/adobe/spectrum-web-components/commit/e767930254e02a544953a396d292502f09f9ae66",
"https://github.com/adobe/spectrum-web-components/commit/740b3ed6ba2dbf958717f8f996e67546ffa02a6b",
"https://g... | 2024-11-12T17:40:15 | 0.0 | TypeScript |
wxt-dev/wxt | 294 | wxt-dev__wxt-294 | [
293
] | 7fd5752ef13e87f889fc3db4868fcaabda26cfba | diff --git a/demo/package.json b/demo/package.json
index 7ba78c265..3e3685345 100644
--- a/demo/package.json
+++ b/demo/package.json
@@ -19,13 +19,11 @@
"dependencies": {
"react": "^18.2.0",
"react-dom": "^18.2.0",
- "vitest": "^0.34.6",
- "webextension-polyfill": "^0.10.0"
+ "vitest": "^1.1.0"
... | diff --git a/demo/src/entrypoints/__tests__/background.test.ts b/demo/src/entrypoints/__tests__/background.test.ts
index 455122e71..42bf30a72 100644
--- a/demo/src/entrypoints/__tests__/background.test.ts
+++ b/demo/src/entrypoints/__tests__/background.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from '... | `wxt/testing` doesn't mock `webextension-polyfill` correctly
### Describe the bug
The polyfill gets loaded into the tests, throwing an error:
```
$ pnpm test run
> demo@1.0.0 test /Users/aklinker1/Downloads/demo
> vitest "run"
RUN v1.1.0 /Users/aklinker1/Downloads/demo
❯ entrypoints/__tests__/bac... | Still not sure why the current solution is working in the `wxt` monorepo and not in real projects...
But I have a solution. For some background: To mock `webextension-polyfill`, Vite needs to process the JS file that imports it. To process the JS file, it needs to be marked as "inline" (or non-external). The current... | Still not sure why the current solution is working in the `wxt` monorepo and not in real projects...
But I have a solution. For some background: To mock `webextension-polyfill`, Vite needs to process the JS file that imports it. To process the JS file, it needs to be marked as "inline" (or non-external). The current... | [
"https://github.com/wxt-dev/wxt/commit/b5614eabc9e10176da1df62a78844c5d17e00649",
"https://github.com/wxt-dev/wxt/commit/a5ed4539b57b99104e20e7f078547272d9b83346",
"https://github.com/wxt-dev/wxt/commit/b06dbc4baceecdccab35044cc4de76babf718ad4"
] | 2023-12-22T22:09:35 | 0.7 | TypeScript |
wxt-dev/wxt | 1,074 | wxt-dev__wxt-1074 | [
1069
] | 1b900e942b648c3adaa960edd9f5a63b47b42f4f | diff --git a/packages/wxt/src/core/resolve-config.ts b/packages/wxt/src/core/resolve-config.ts
index 8269179ca..5c2b9cd9d 100644
--- a/packages/wxt/src/core/resolve-config.ts
+++ b/packages/wxt/src/core/resolve-config.ts
@@ -96,7 +96,21 @@ export async function resolveConfig(
const publicDir = path.resolve(srcDir, m... | diff --git a/packages/wxt/e2e/tests/user-config.test.ts b/packages/wxt/e2e/tests/user-config.test.ts
index 01ac7f4d1..c0b497508 100644
--- a/packages/wxt/e2e/tests/user-config.test.ts
+++ b/packages/wxt/e2e/tests/user-config.test.ts
@@ -130,4 +130,31 @@ describe('User Config', () => {
await project.fileExists('.... | `outDirTemplate` for customizing output directory
### Feature Request
Add a new config, `outDirTemplate`, that defaults to `{{browser}}-mv{{manifestVersion}}`. Template variables are:
| Template Var | Value |
| --- | --- |
| `{{browser}}` | `wxt.config.browser`
| `{{manifestVersion}}` | `wxt.config.manifestVer... | Released in [`v0.19.12`](https://github.com/wxt-dev/wxt/releases/tag/wxt-v0.19.12)
| [
"https://github.com/wxt-dev/wxt/commit/5325089e2a71e43f710c4eb896daff68c7f04f09",
"https://github.com/wxt-dev/wxt/commit/b5348609fe4f26315bf9423a26d5bfad14fc4f12",
"https://github.com/wxt-dev/wxt/commit/0ea504dba7c8fafb5aac4d45095d6ad733dc0904",
"https://github.com/wxt-dev/wxt/commit/1044dc069fda93dab465a5310... | 2024-10-17T14:26:43 | 0.2 | TypeScript | |
wxt-dev/wxt | 1,590 | wxt-dev__wxt-1590 | [
1580
] | 7c59e9d5b5f79819a5a2f1983153cc6a96854ca0 | diff --git a/packages/wxt/src/core/builders/vite/index.ts b/packages/wxt/src/core/builders/vite/index.ts
index 8eb2068ab..c798749da 100644
--- a/packages/wxt/src/core/builders/vite/index.ts
+++ b/packages/wxt/src/core/builders/vite/index.ts
@@ -308,7 +308,10 @@ export async function createViteBuilder(
async build(... | diff --git a/packages/wxt/e2e/tests/output-structure.test.ts b/packages/wxt/e2e/tests/output-structure.test.ts
index 4fd96d354..2c08556ff 100644
--- a/packages/wxt/e2e/tests/output-structure.test.ts
+++ b/packages/wxt/e2e/tests/output-structure.test.ts
@@ -220,6 +220,77 @@ describe('Output Directory Structure', () => {... | Unlisted CSS using preprocessor does not build css file
### Describe the bug
I encountered a situation where I needed to add a stylesheet dynamically, so I tried using unlisted CSS. I created a .scss as unlisted CSS, but the scss file was not generated as a CSS output.
When adding regular .css as unlisted CSS, it wor... | I have submitted a PR to fix this issue. #1590
After further investigation, I found that the same issue not only with Sass but with all CSS preprocessors, so I have updated the title
| I have submitted a PR to fix this issue. #1590
After further investigation, I found that the same issue not only with Sass but with all CSS preprocessors, so I have updated the title
| [
"https://github.com/wxt-dev/wxt/commit/cef5945882899513f52e08990f25dbae1f9e787f",
"https://github.com/wxt-dev/wxt/commit/4dbaec22a4c4dff45be86aa2f4316cbde7a35702",
"https://github.com/wxt-dev/wxt/commit/9ddeb25ecf05cda81b990a9ea3588bb2d4919f7f"
] | 2025-04-18T09:45:44 | 0.5 | TypeScript |
wxt-dev/wxt | 1,407 | wxt-dev__wxt-1407 | [
1403
] | 868a347d40c54bcc78f20f099a1a0cd8a7175cc5 | diff --git a/docs/guide/essentials/config/typescript.md b/docs/guide/essentials/config/typescript.md
index be2208832..8d939e2e0 100644
--- a/docs/guide/essentials/config/typescript.md
+++ b/docs/guide/essentials/config/typescript.md
@@ -14,7 +14,7 @@ At a minimum, you need to create a TSConfig in your root directory th... | diff --git a/packages/wxt/e2e/tests/auto-imports.test.ts b/packages/wxt/e2e/tests/auto-imports.test.ts
index f8b58e4e6..144b972e8 100644
--- a/packages/wxt/e2e/tests/auto-imports.test.ts
+++ b/packages/wxt/e2e/tests/auto-imports.test.ts
@@ -52,10 +52,10 @@ describe('Auto Imports', () => {
-------------------... | Incorrect use of triple-slash directives
### Describe the bug
Both in code (e.g. [here](https://github.com/wxt-dev/wxt/blob/48a87aa352edbd0d095864fe1c14b50682f78dee/packages/wxt/src/core/generate-wxt-dir.ts#L220)) and documentation (e.g. [here](https://github.com/wxt-dev/wxt/blob/48a87aa352edbd0d095864fe1c14b50682f78d... | Good find, thanks for the info. I can get to this next week, or if you're willing, I'd accept a PR! You've already linked to all the relevant code, I don't think there's any other relevant lines that need changed.
| Good find, thanks for the info. I can get to this next week, or if you're willing, I'd accept a PR! You've already linked to all the relevant code, I don't think there's any other relevant lines that need changed.
Fix released in [v0.19.27](https://github.com/wxt-dev/wxt/releases/tag/wxt-v0.19.27)
| [
"https://github.com/wxt-dev/wxt/commit/b96fa08c294b504ad2905fe9f26ef34ed8119863",
"https://github.com/wxt-dev/wxt/commit/c323d334409fea80ca681e562dffb17270ccc426"
] | 2025-02-07T16:53:10 | 2.0 | TypeScript |
wxt-dev/wxt | 865 | wxt-dev__wxt-865 | [
864
] | 9eb64d94d6ad53429b3bfcb080eb9e90dcb02b8a | diff --git a/packages/wxt/package.json b/packages/wxt/package.json
index 89ba57ae8..271d3db01 100644
--- a/packages/wxt/package.json
+++ b/packages/wxt/package.json
@@ -1,7 +1,7 @@
{
"name": "wxt",
"type": "module",
- "version": "0.19.0",
+ "version": "0.19.1-alpha2",
"description": "Next gen framework for ... | diff --git a/packages/wxt/e2e/tests/remote-code.test.ts b/packages/wxt/e2e/tests/remote-code.test.ts
index 481a9e9c9..f4ac9f935 100644
--- a/packages/wxt/e2e/tests/remote-code.test.ts
+++ b/packages/wxt/e2e/tests/remote-code.test.ts
@@ -3,7 +3,7 @@ import { TestProject } from '../utils';
describe('Remote Code', () =... | window not defined in content shared file in v0.19
### Describe the bug
I have a content script which has a react code.
I have created constant file from which i export window variable.
the `wxt prepare` command fails
<details>
<summary>Error logs</summary>
```
> wxt prepare
WXT 0.19.0 ... | I have the same issue, the side effect of the import statement is triggered in v0.19.0, but not in v.0.18.0.
Pinged @aklinker1 about this in the Discord but seems to be an issue from the move to tsup, same behaviour with `self`
@aiktb @Timeraa @mehimanshupatil Can you guys try out `wxt@0.19.1-alpha1` and let me know if... | I have the same issue, the side effect of the import statement is triggered in v0.19.0, but not in v.0.18.0.
Pinged @aklinker1 about this in the Discord but seems to be an issue from the move to tsup, same behaviour with `self`
@aiktb @Timeraa @mehimanshupatil Can you guys try out `wxt@0.19.1-alpha1` and let me know if... | [
"https://github.com/wxt-dev/wxt/commit/4b7f43d5588899cb4fd956342dbacd00af270e41",
"https://github.com/wxt-dev/wxt/commit/1d60e2eba0367b5559c87f3327b11d3b564b2a16",
"https://github.com/wxt-dev/wxt/commit/f449c2b80b67f78ec652e9951f8785c0cdffd968",
"https://github.com/wxt-dev/wxt/commit/17059c3a4322add23027f0321... | 2024-07-26T20:04:56 | 1.0 | TypeScript |
google-gemini/gemini-cli | 7,408 | google-gemini__gemini-cli-7408 | [
7043
] | 4c38227256e3618a6eafe023684082d0538cc7b0 | diff --git a/packages/vscode-ide-companion/src/extension.ts b/packages/vscode-ide-companion/src/extension.ts
index 36fc4029d10..66020cb94f3 100644
--- a/packages/vscode-ide-companion/src/extension.ts
+++ b/packages/vscode-ide-companion/src/extension.ts
@@ -6,9 +6,11 @@
import * as vscode from 'vscode';
import { IDE... | diff --git a/packages/vscode-ide-companion/src/extension.test.ts b/packages/vscode-ide-companion/src/extension.test.ts
index 2223050bcfa..8377c01e97d 100644
--- a/packages/vscode-ide-companion/src/extension.test.ts
+++ b/packages/vscode-ide-companion/src/extension.test.ts
@@ -50,12 +50,18 @@ vi.mock('vscode', () => ({
... | Notify users when a new version of the Gemini CLI Companion extension is available
### What would you like to be added?
A notification that alerts users when a new version of the Gemini CLI Companion extension is available and provides a clear call to action to update.
This notification should include:
- A message th... | [
"https://github.com/google-gemini/gemini-cli/commit/5b28f848e667dd04fc4a4b79298eb7182257da54",
"https://github.com/google-gemini/gemini-cli/commit/13ef858a94b396ebac6d5839c7168509fb4649d0",
"https://github.com/google-gemini/gemini-cli/commit/ca9aa6e9cf849d27eb4ba4ec7b55ede5e15219e1",
"https://github.com/googl... | 2025-08-29T16:20:56 | 0.4 | TypeScript | ||
google-gemini/gemini-cli | 4,141 | google-gemini__gemini-cli-4141 | [
4029
] | c313c3dee1872a0edc943ad096eab68a03a3dda5 | diff --git a/packages/core/src/core/client.ts b/packages/core/src/core/client.ts
index ed903788b7a..d8143d05ac0 100644
--- a/packages/core/src/core/client.ts
+++ b/packages/core/src/core/client.ts
@@ -30,6 +30,7 @@ import { reportError } from '../utils/errorReporting.js';
import { GeminiChat } from './geminiChat.js';
... | diff --git a/packages/core/src/core/client.test.ts b/packages/core/src/core/client.test.ts
index bbcb549b1f3..03793bdac29 100644
--- a/packages/core/src/core/client.test.ts
+++ b/packages/core/src/core/client.test.ts
@@ -470,34 +470,31 @@ describe('Gemini Client (client.ts)', () => {
describe('tryCompressChat', () =... | Compression can result in 400s and inability to continue conversation
### What happened?
after hitting limit of tokens, the cli attempt a compress if you redo a compress afterward it fails, but then the conversation is not recoverable as it get stuck replying systematically 400 code with below message :
Please ensure ... | @scidomino see linked duplicate issue I put more context there.
I also encountered a similar problem. I wrote a summary reference after reading a large number of documents (~170) using Gemini. However, it may be that the free quota for the day has been used up, so I am stuck here. But in short, no matter how I use othe... | @scidomino see linked duplicate issue I put more context there.
I also encountered a similar problem. I wrote a summary reference after reading a large number of documents (~170) using Gemini. However, it may be that the free quota for the day has been used up, so I am stuck here. But in short, no matter how I use othe... | [
"https://github.com/google-gemini/gemini-cli/commit/dedcea2be48dfea641f7a134e2fc946ee249572d"
] | 2025-07-14T16:38:49 | 0.1 | TypeScript |
google-gemini/gemini-cli | 6,397 | google-gemini__gemini-cli-6397 | [
4588
] | 1a89d185269df6b492f9960c7efb140890bf75b1 | diff --git a/packages/cli/src/gemini.tsx b/packages/cli/src/gemini.tsx
index b285a5af223..f9cacfb7afe 100644
--- a/packages/cli/src/gemini.tsx
+++ b/packages/cli/src/gemini.tsx
@@ -342,7 +342,9 @@ export async function main() {
}
}
if (!input) {
- console.error('No input provided via stdin.');
+ consol... | diff --git a/integration-tests/stdin-context.test.ts b/integration-tests/stdin-context.test.ts
index c7c89a9110c..912fa0c2c5d 100644
--- a/integration-tests/stdin-context.test.ts
+++ b/integration-tests/stdin-context.test.ts
@@ -67,4 +67,31 @@ describe('stdin context', () => {
'Expected the model to identify the... | Git Bash on windows doesn't run the gemini command.
### What happened?
When trying to run ```gemini``` command in a git bash terminal on windows, nothing happens. The program doesn't start the auth process, nor does it seem to even operate. The terminal just gets stale and nothing happens. Running it as administrator ... | Hey @jacob314, i have been thinking about how to solve this issue, this happens because when input is not TTY, piped input is expected but there is no piped input, this keeps the cli waiting for input from stdin.
There are multiple ways to solve this issue.
**Approach1**: wait for some time T, if there is no input f... | Hey @jacob314, i have been thinking about how to solve this issue, this happens because when input is not TTY, piped input is expected but there is no piped input, this keeps the cli waiting for input from stdin.
There are multiple ways to solve this issue.
**Approach1**: wait for some time T, if there is no input f... | [
"https://github.com/google-gemini/gemini-cli/commit/2a1ef2f18ed159d7f7638141295fc06b3dd78972",
"https://github.com/google-gemini/gemini-cli/commit/4df777f61a77240bc87aa117f1b9827bf0dc210d",
"https://github.com/google-gemini/gemini-cli/commit/d4febe76f83b366d3debefa485f9775146cce732",
"https://github.com/googl... | 2025-08-16T21:35:04 | 0.3 | TypeScript |
google-gemini/gemini-cli | 7,167 | google-gemini__gemini-cli-7167 | [
5239
] | 3e74ff71b7a2094b2ad23740c605a50b9b06d965 | diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
index c36340db11a..350df660d2a 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.ts
@@ -393,9 +393,9 @@ export const useSlashCommandPro... | diff --git a/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts b/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
index 7099e2e6692..0a92a085d50 100644
--- a/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
+++ b/packages/cli/src/ui/hooks/slashCommandProcessor.test.ts
@@ -417,6 +417,44 @@ describe('... | If I save a chat when signed in with an API key and then try to load it when signed in with my gmail account, I get fatal errors when I try to enter another prompt.
### What happened?
Enter a conversation. Can be as trivial as
`1+1`
`/chat save add`
`/auth`
`/chat resume add`
Now if you type anything in the chat you g... | [
"https://github.com/google-gemini/gemini-cli/commit/2a1fa72fce76973052675b72e1278a5f02715e6e"
] | 2025-08-26T23:51:39 | 0.2 | TypeScript | ||
google-gemini/gemini-cli | 10,951 | google-gemini__gemini-cli-10951 | [
10927
] | 09ef33ec3a5ea9b9d09ff0a43c6013f66bcc4641 | diff --git a/packages/cli/src/nonInteractiveCli.ts b/packages/cli/src/nonInteractiveCli.ts
index 9a5e5fad09e..54f9eb909ea 100644
--- a/packages/cli/src/nonInteractiveCli.ts
+++ b/packages/cli/src/nonInteractiveCli.ts
@@ -4,7 +4,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
-import type { Config, ToolCallRequestI... | diff --git a/packages/cli/src/nonInteractiveCli.test.ts b/packages/cli/src/nonInteractiveCli.test.ts
index c1240cbed95..e201e850c51 100644
--- a/packages/cli/src/nonInteractiveCli.test.ts
+++ b/packages/cli/src/nonInteractiveCli.test.ts
@@ -9,6 +9,8 @@ import type {
ToolRegistry,
ServerGeminiStreamEvent,
Sessi... | Bug: Non-interactive sessions do not log tool calls in session history
### What happened?
When running the Gemini CLI in a non-interactive session (using the `-p` flag), tool call information is not being recorded in the automatically saved session history JSON files. However, when running in an interactive session (w... | @sniemczyk-google I have a PR in: #10951.
| @sniemczyk-google I have a PR in: #10951.
| [
"https://github.com/google-gemini/gemini-cli/commit/327092f9dd1abf5c455746a7f944041cc584f7dc"
] | 2025-10-11T15:09:46 | 0.6 | TypeScript |
capricorn86/happy-dom | 886 | capricorn86__happy-dom-886 | [
875
] | f8618cdad8e6ad08aae59c44bdddabda9d92afec | diff --git a/packages/happy-dom/src/nodes/element/HTMLCollection.ts b/packages/happy-dom/src/nodes/element/HTMLCollection.ts
index b9b6ac147..eb66f68e6 100644
--- a/packages/happy-dom/src/nodes/element/HTMLCollection.ts
+++ b/packages/happy-dom/src/nodes/element/HTMLCollection.ts
@@ -41,7 +41,7 @@ export default class ... | diff --git a/packages/happy-dom/test/nodes/element/HTMLCollection.test.ts b/packages/happy-dom/test/nodes/element/HTMLCollection.test.ts
index fb150ece0..e0fd70979 100644
--- a/packages/happy-dom/test/nodes/element/HTMLCollection.test.ts
+++ b/packages/happy-dom/test/nodes/element/HTMLCollection.test.ts
@@ -117,5 +117,... | RangeError: Invalid array length
**Describe the bug**
I use innerHTML to insert a piece of html, then error occurs.
**To Reproduce**
Steps to reproduce the behavior:
just use node to run code below:
```js
import { GlobalRegistrator } from '@happy-dom/global-registrator'
GlobalRegistrator.register()
document... | Thank you for reporting @lovetingyuan! :slightly_smiling_face:
The issue has been fixed now.
This was a pretty serious bug. Hopefully it is not common to use names or id:s with the same name as methods and properties of the HTMLCollection class.
You can read more about the release here:
https://github.com/ca... | Thank you for reporting @lovetingyuan! :slightly_smiling_face:
The issue has been fixed now.
This was a pretty serious bug. Hopefully it is not common to use names or id:s with the same name as methods and properties of the HTMLCollection class.
You can read more about the release here:
https://github.com/ca... | [
"https://github.com/capricorn86/happy-dom/commit/6f4e4708d02345900c81b3190266c5fc71786118"
] | 2023-05-02T15:32:40 | 0.0 | TypeScript |
capricorn86/happy-dom | 1,169 | capricorn86__happy-dom-1169 | [
1168
] | 2d0c458c7f0aff85bab9cad8e2fea911cfa355e8 | diff --git a/packages/happy-dom/src/dom-token-list/DOMTokenList.ts b/packages/happy-dom/src/dom-token-list/DOMTokenList.ts
index 04b40e89c..a36a24102 100644
--- a/packages/happy-dom/src/dom-token-list/DOMTokenList.ts
+++ b/packages/happy-dom/src/dom-token-list/DOMTokenList.ts
@@ -2,6 +2,8 @@ import Element from '../nod... | diff --git a/packages/happy-dom/test/dom-token-list/DOMTokenList.test.ts b/packages/happy-dom/test/dom-token-list/DOMTokenList.test.ts
index b57aa0149..3951c7c7a 100644
--- a/packages/happy-dom/test/dom-token-list/DOMTokenList.test.ts
+++ b/packages/happy-dom/test/dom-token-list/DOMTokenList.test.ts
@@ -211,4 +211,12 @... | Element.classList has empty string item when a class attribute contains multiple spaces
**Describe the bug**
Element.classList has empty string item when a class attribute contains multiple spaces. Multiple spaces should be compressed and Element.classList should not have empty string item.
**To Reproduce**
Steps... | [
"https://github.com/capricorn86/happy-dom/commit/5824775c58a4abb450f9b42a05670bb6eefa2e6a",
"https://github.com/capricorn86/happy-dom/commit/1f5a30137f4ad0ee944bf5c1b2732a41be14347d",
"https://github.com/capricorn86/happy-dom/commit/74c4d064191e966789d1ebade9f7617c27b3241e",
"https://github.com/capricorn86/ha... | 2023-11-24T07:56:00 | 0.0 | TypeScript | ||
capricorn86/happy-dom | 1,755 | capricorn86__happy-dom-1755 | [
1698
] | 0452d7cef78bce337bb4afeb87a749fd79e0c9e1 | diff --git a/packages/happy-dom/src/nodes/node/NodeList.ts b/packages/happy-dom/src/nodes/node/NodeList.ts
index 71b49276e..fac6bf517 100644
--- a/packages/happy-dom/src/nodes/node/NodeList.ts
+++ b/packages/happy-dom/src/nodes/node/NodeList.ts
@@ -38,6 +38,9 @@ class NodeList<T extends Node> {
methodBinder.bind(... | diff --git a/packages/happy-dom/test/nodes/node/NodeList.test.ts b/packages/happy-dom/test/nodes/node/NodeList.test.ts
index 7f7e0a81d..45d6f0c52 100644
--- a/packages/happy-dom/test/nodes/node/NodeList.test.ts
+++ b/packages/happy-dom/test/nodes/node/NodeList.test.ts
@@ -22,6 +22,21 @@ describe('NodeList', () => {
... | NodeList gets the first element when you pass and empty array as index
**Describe the bug**
When you use an empty array as an index of a NodeList it returns the first element instead of undefined.
**To Reproduce**
Steps to reproduce the behavior:
We have the following function:
```javascript
const getActiveTabTrackId ... | [
"https://github.com/capricorn86/happy-dom/commit/503c3b1cd773306a2b37c979da6780933135b430",
"https://github.com/capricorn86/happy-dom/commit/4ca57415dfeaf6c3642d92b567fa304ec3496178"
] | 2025-03-01T17:42:16 | 0.0 | TypeScript | ||
capricorn86/happy-dom | 812 | capricorn86__happy-dom-812 | [
811
] | 5d35044852e862b33d112fd28134a7ac99529ccc | diff --git a/packages/happy-dom/src/nodes/svg-element/SVGElement.ts b/packages/happy-dom/src/nodes/svg-element/SVGElement.ts
index 664e0c10d..de8a10d74 100644
--- a/packages/happy-dom/src/nodes/svg-element/SVGElement.ts
+++ b/packages/happy-dom/src/nodes/svg-element/SVGElement.ts
@@ -37,11 +37,13 @@ export default clas... | diff --git a/packages/happy-dom/test/nodes/svg-element/SVGElement.test.ts b/packages/happy-dom/test/nodes/svg-element/SVGElement.test.ts
new file mode 100644
index 000000000..ca06abd80
--- /dev/null
+++ b/packages/happy-dom/test/nodes/svg-element/SVGElement.test.ts
@@ -0,0 +1,32 @@
+import Window from '../../../src/win... | SVGElement.ownerSVGElement cannot exit if not in svg
**Describe the bug**
When I was using SVG nodes and tried to use the ownerSVGElement property, I ended up in an infinite loop. Upon checking the code, I found the following issue.
![image](https://user-images.githubusercontent.com/56526981/223290250-e91aadf7-aad5... | Thanks for your contribution @linghaoSu! :slightly_smiling_face:
| [
"https://github.com/capricorn86/happy-dom/commit/d26bfad3fa323325eec2265b2cba68d31d3da5c5",
"https://github.com/capricorn86/happy-dom/commit/22d6fdec654bb74f6d0f98eda2a5067d333bc299"
] | 2023-03-07T01:15:05 | 0.0 | TypeScript | |
capricorn86/happy-dom | 1,911 | capricorn86__happy-dom-1911 | [
1620
] | 220df23dea106ad29c60393e6ebcffe5d2ce3af7 | diff --git a/packages/happy-dom/src/nodes/document/Document.ts b/packages/happy-dom/src/nodes/document/Document.ts
index 241d86b91..bf6d67fcd 100644
--- a/packages/happy-dom/src/nodes/document/Document.ts
+++ b/packages/happy-dom/src/nodes/document/Document.ts
@@ -1472,7 +1472,7 @@ export default class Document extends... | diff --git a/packages/happy-dom/test/query-selector/QuerySelector.test.ts b/packages/happy-dom/test/query-selector/QuerySelector.test.ts
index 9061490ec..05be773cf 100644
--- a/packages/happy-dom/test/query-selector/QuerySelector.test.ts
+++ b/packages/happy-dom/test/query-selector/QuerySelector.test.ts
@@ -1369,6 +136... | `:scope` no longer works
**Describe the bug**
since `happy-dom@13`, `Element` methods with selector string argument seem to no more support `:scope` selector
* `.queySelector()`
* `.querySelectorAll()`
* `.matches()`
**To Reproduce**
Steps to reproduce the behavior:
1. `npm i happy-dom`
2. create this file:
... | Thank you for reporting @yukulele!
There was no support for `:scope`, but query selectors returned it as a match even though it wasn't supported. This has finally been fixed by adding support for it.
Thanks for your work on this @capricorn86. Unfortunately, I'm still seeing some inconsistent behavior with the `:scope`... | Thank you for reporting @yukulele!
There was no support for `:scope`, but query selectors returned it as a match even though it wasn't supported. This has finally been fixed by adding support for it.
Thanks for your work on this @capricorn86. Unfortunately, I'm still seeing some inconsistent behavior with the `:scope`... | [
"https://github.com/capricorn86/happy-dom/commit/503b7762fe00d49acaa1f9797ed3d8d30fa7d7cd",
"https://github.com/capricorn86/happy-dom/commit/f5da5fb8c0cd27cf12d642f55d9bb776572c6935",
"https://github.com/capricorn86/happy-dom/commit/5afa0d81c80bd1f3f4bc6b55026971710aa8865f"
] | 2025-09-29T22:21:29 | 0.0 | TypeScript |
opensearch-project/OpenSearch-Dashboards | 7,022 | opensearch-project__OpenSearch-Dashboards-7022 | [
6996
] | 83317a231212d6770da9adadc20e40f65b1136dc | diff --git a/src/plugins/data/public/ui/filter_bar/filter_editor/value_input_type.tsx b/src/plugins/data/public/ui/filter_bar/filter_editor/value_input_type.tsx
index 9d7709a5f667..fd1743e96c12 100644
--- a/src/plugins/data/public/ui/filter_bar/filter_editor/value_input_type.tsx
+++ b/src/plugins/data/public/ui/filter_... | diff --git a/src/plugins/data/public/ui/filter_bar/filter_editor/value_input_type.test.tsx b/src/plugins/data/public/ui/filter_bar/filter_editor/value_input_type.test.tsx
new file mode 100644
index 000000000000..aa4f4b4cd213
--- /dev/null
+++ b/src/plugins/data/public/ui/filter_bar/filter_editor/value_input_type.test.t... | [BUG] is filter not working with numeric Scripted fields
**Describe the bug**
Adding filters for scripted numeric fields using `is` operator after clicking the **Add Filter** Button does not produce any result. However directly clicking on a visualization containing the required field adds the filter correctly. This ... | Was able to reproduce this bug.
When we add a filter by clicking on one of the bar on the visualization, it will send the query value as number type, `"value": 66`; whhen we add a filter using `add filter` button from the filter bar, it will send the query value as string type, `"value": "66"`.
The above flows ... | Was able to reproduce this bug.
When we add a filter by clicking on one of the bar on the visualization, it will send the query value as number type, `"value": 66`; whhen we add a filter using `add filter` button from the filter bar, it will send the query value as string type, `"value": "66"`.
The above flows ... | [
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/d6faaa51cd3b81023b96576c0c481882afa215c5",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/954d6e20b33bd8a46cc3a9b5e8d6453cde107382",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/b96cd14b7c559f2bde29da... | 2024-06-13T19:45:07 | 2.16 | TypeScript |
opensearch-project/OpenSearch-Dashboards | 4,365 | opensearch-project__OpenSearch-Dashboards-4365 | [
4321
] | e451d137403bb2e3144ee1492810a183dade8ea1 | diff --git a/CHANGELOG.md b/CHANGELOG.md
index d4a160ccb9bc..b04ae7db4682 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -82,6 +82,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
- Replace the use of `bluebird` in `saved_objects` plugin ([#4026](https://github.com/opensearch-project/OpenSe... | diff --git a/src/plugins/vis_type_vislib/public/vislib/components/legend/legend.test.tsx b/src/plugins/vis_type_vislib/public/vislib/components/legend/legend.test.tsx
index 18192c3faa34..1038c663d0dc 100644
--- a/src/plugins/vis_type_vislib/public/vislib/components/legend/legend.test.tsx
+++ b/src/plugins/vis_type_visl... | [Vis colors] Update legend colors to use ouiPaletteColorBlind()-derived scales
Many OpenSearch Dashboard visualizations provide an interactive legend that provides users with a (non-OUI) color picker to alter the color associated with a particular visualization series. Not only do the available legend colors not match ... | [
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/2e3df158d786f5780773ee42e3ee823fd23ff149",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/74287ca5014cffd8c1ff4116595a2ad7ca0ad26b",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/1f5f7b8d26b0cb82597f5c... | 2023-06-22T21:18:09 | 2.9 | TypeScript | ||
opensearch-project/OpenSearch-Dashboards | 10,361 | opensearch-project__OpenSearch-Dashboards-10361 | [
2343,
10105
] | 5bd94df7ae0953791213fc6defd11a0085d07a4f | diff --git a/changelogs/fragments/10361.yml b/changelogs/fragments/10361.yml
new file mode 100644
index 000000000000..9d9542c42e7b
--- /dev/null
+++ b/changelogs/fragments/10361.yml
@@ -0,0 +1,2 @@
+feat:
+- Add support for PATCH in dev tools ([#10361](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/10... | diff --git a/src/core/test_helpers/osd_server.ts b/src/core/test_helpers/osd_server.ts
index ff98a49f6999..1316833c1787 100644
--- a/src/core/test_helpers/osd_server.ts
+++ b/src/core/test_helpers/osd_server.ts
@@ -47,7 +47,7 @@ import { CliArgs, Env } from '../server/config';
import { Root } from '../server/root';
i... | Dev Tools should support PATCH method
### Reproduction:
- Find some documentation about a scenario in OpenSearch APIs that use a PATCH command, [like](https://opensearch.org/docs/latest/security-plugin/access-control/api/#patch-role)
- Get excited to try it out in your own cluster
- Open Dashboards, login as an admi... | FYI @cwillum
It seems that the request method simply isn't in the list here:
https://github.com/opensearch-project/OpenSearch-Dashboards/blob/06abe83e0180f391a84c742cf5594866bc747ea2/src/plugins/console/server/routes/api/console/proxy/validation_config.ts#L37-L43
Something else of note is that it looks like the ... | FYI @cwillum
It seems that the request method simply isn't in the list here:
https://github.com/opensearch-project/OpenSearch-Dashboards/blob/06abe83e0180f391a84c742cf5594866bc747ea2/src/plugins/console/server/routes/api/console/proxy/validation_config.ts#L37-L43
Something else of note is that it looks like the ... | [
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/f119c2c26887893d36818913695e19f53892ca61",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/21579578200c6923798f8f53ef055037801d801f",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/b71fd880750f6d884110ee... | 2025-08-06T21:12:46 | 3.3 | TypeScript |
opensearch-project/OpenSearch-Dashboards | 9,176 | opensearch-project__OpenSearch-Dashboards-9176 | [
5476
] | 53fe4c1064b776b214e5de5c2c809b921640d91a | diff --git a/changelogs/fragments/9167.yml b/changelogs/fragments/9167.yml
new file mode 100644
index 000000000000..028d20a5be56
--- /dev/null
+++ b/changelogs/fragments/9167.yml
@@ -0,0 +1,2 @@
+fix:
+- Cleanup OsdUrlStateStorage subscription in TopNav ([#9167](https://github.com/opensearch-project/OpenSearch-Dashboar... | diff --git a/src/plugins/data/public/query/state_sync/connect_to_query_state.test.ts b/src/plugins/data/public/query/state_sync/connect_to_query_state.test.ts
index 034a4f218fbd..1c243c7b0ba6 100644
--- a/src/plugins/data/public/query/state_sync/connect_to_query_state.test.ts
+++ b/src/plugins/data/public/query/state_s... | [BUG] ScopedHistory instance has fell out of scope for basePath: `/app/data-explorer`
**Describe the bug**
When we switch the query language in discover page, the console outputs the below error. On top of that, the action of navigating from discover page to another page will output a series of the following error a... | @joshuarrrr Can I try this one?
@ashwin-pc here is the screenshot recording, i started the dashboard in Incognito:
https://github.com/opensearch-project/OpenSearch-Dashboards/assets/43937633/7e7486f2-5980-488c-9c1f-c6b4a82fe570
Hi,
is this related to my issue that the browser back button is not working like it ... | @joshuarrrr Can I try this one?
@ashwin-pc here is the screenshot recording, i started the dashboard in Incognito:
https://github.com/opensearch-project/OpenSearch-Dashboards/assets/43937633/7e7486f2-5980-488c-9c1f-c6b4a82fe570
Hi,
is this related to my issue that the browser back button is not working like it ... | [
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/579b0a26d52e4464c9421f33f7e94ccdf74e80b7"
] | 2025-01-13T19:12:48 | 2.19 | TypeScript |
opensearch-project/OpenSearch-Dashboards | 5,881 | opensearch-project__OpenSearch-Dashboards-5881 | [
5692
] | 4ab0ca8cd34cea2c4bb746d32e2b00b60d671cbe | diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d4a5efcb1ef..5819b11f7d41 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -42,6 +42,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
- [Multiple Datasource] Able to Hide "Local Cluster" option from datasource DropDown ([#5827](https://github.co... | diff --git a/src/plugins/data_source/server/client/configure_client.test.mocks.ts b/src/plugins/data_source/server/client/configure_client.test.mocks.ts
index 38a585ff2020..787954a5f97b 100644
--- a/src/plugins/data_source/server/client/configure_client.test.mocks.ts
+++ b/src/plugins/data_source/server/client/configur... | [Proposal] Refactoring data source plugin to support add-on authentication method with plug-in module
# Overview
The purpose of this design document is to outline the approach and specifications for adding an interface in multi data source plugin that allows the seamless integration of authentication method through pl... | [
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/f332650401fcb2d0f38228ffbe293c75554be21c",
"https://github.com/opensearch-project/OpenSearch-Dashboards/commit/d0b1d2b759807536fa30d31858216613fa66160a"
] | 2024-02-15T22:31:15 | 2.12 | TypeScript | ||
vscode-neovim/vscode-neovim | 1,619 | vscode-neovim__vscode-neovim-1619 | [
1612,
1618
] | 48f6d5a93dbedabcbdec46a79fe37e47d1995d2b | diff --git a/src/document_change_manager.ts b/src/document_change_manager.ts
index 3ba064266..d05992084 100644
--- a/src/document_change_manager.ts
+++ b/src/document_change_manager.ts
@@ -256,9 +256,8 @@ export class DocumentChangeManager implements Disposable {
logger.debug(`No visible text e... | diff --git a/src/test/suite/basic-editing-navigation.test.ts b/src/test/suite/basic-editing-navigation.test.ts
index 40b11d12e..81a3fd673 100644
--- a/src/test/suite/basic-editing-navigation.test.ts
+++ b/src/test/suite/basic-editing-navigation.test.ts
@@ -1,4 +1,7 @@
+import { strict as assert } from "assert";
+
impo... | bug: latest dev build is pasting wrong data from buffer.
### Did you check docs and existing issues?
- [X] I have read all the vscode-neovim docs
- [X] I have searched the existing issues of vscode-neovim
- [X] I can reproduce the issue with an empty init.vim/init.lua and no other vscode extensions (when applicable)
... | Does every file have this issue? Can you upload a file that reproduces the issue?
https://github.com/rayzorben/mudengine/blob/main/src/engine/user.coffee line 572
other files seem fine but I only tested about 3
I can't reproduce 👀
| Does every file have this issue? Can you upload a file that reproduces the issue?
https://github.com/rayzorben/mudengine/blob/main/src/engine/user.coffee line 572
other files seem fine but I only tested about 3
I can't reproduce 👀
| [
"https://github.com/vscode-neovim/vscode-neovim/commit/74ea1e9dffdedbc9970a229a0d47bcd6dad69271",
"https://github.com/vscode-neovim/vscode-neovim/commit/95158fd6781ff3ca18854f31db2851f8cc28e572",
"https://github.com/vscode-neovim/vscode-neovim/commit/a5939e154e0cb922f7b6eba62afdf3ad0e291613"
] | 2023-11-15T14:44:53 | 1.0 | TypeScript |
vscode-neovim/vscode-neovim | 1,401 | vscode-neovim__vscode-neovim-1401 | [
1144,
1368,
1374
] | 242e2bdffee8c9ab883e06d0165a453d4f3e28d6 | diff --git a/runtime/lua/vscode-neovim/cursor.lua b/runtime/lua/vscode-neovim/cursor.lua
index dc549b897..e5d73ab22 100644
--- a/runtime/lua/vscode-neovim/cursor.lua
+++ b/runtime/lua/vscode-neovim/cursor.lua
@@ -90,6 +90,8 @@ function M.highlight_fake_cursor()
local line = vim.fn.line(".")
local col = vim.fn... | diff --git a/.github/workflows/build_test.yml b/.github/workflows/build_test.yml
index 96b72ca82..74d11fde6 100644
--- a/.github/workflows/build_test.yml
+++ b/.github/workflows/build_test.yml
@@ -26,7 +26,8 @@ jobs:
id: vim
with:
neovim: true
- version:... | Bug: Visual mode for files makes letters appear in the line that is selected
Have disabled all other plugins expect the colorscheme.
https://user-images.githubusercontent.com/7727602/215477372-ce102f74-c17e-4ac6-8b82-3ab926d48320.mov
bug: ghost cursor
### Did you check docs and existing issues?
- [X] I have r... | I've been seeing this for a while too, possibly since the last update?
Perhaps worth noting is this seems to be cosmetic — the selection will look garbled, but as far as I can tell the backing buffer has the right selection, since e.g. `vi(y` still works as expected and yank the selection.
same issue, but looks like... | I've been seeing this for a while too, possibly since the last update?
Perhaps worth noting is this seems to be cosmetic — the selection will look garbled, but as far as I can tell the backing buffer has the right selection, since e.g. `vi(y` still works as expected and yank the selection.
same issue, but looks like... | [
"https://github.com/vscode-neovim/vscode-neovim/commit/0ebe821f612acd999344e88682f520ad16c03596",
"https://github.com/vscode-neovim/vscode-neovim/commit/c6d4a2f817ce69a8534867b9ba4ae20762bf84f9",
"https://github.com/vscode-neovim/vscode-neovim/commit/63676fd17d5f172a1594a3ab6c878be6d62e1798",
"https://github.... | 2023-08-28T15:27:08 | 0.4 | TypeScript |
vscode-neovim/vscode-neovim | 1,167 | vscode-neovim__vscode-neovim-1167 | [
1185
] | 364aa275cd776eba3d9fdb3009261f655bfd11f1 | diff --git a/src/document_change_manager.ts b/src/document_change_manager.ts
index dfb94f5a0..dd4e7d1fa 100644
--- a/src/document_change_manager.ts
+++ b/src/document_change_manager.ts
@@ -177,11 +177,12 @@ export class DocumentChangeManager implements Disposable, NeovimExtensionRequest
dotRepeatChange... | diff --git a/src/test/suite/dot-repeat.test.ts b/src/test/suite/dot-repeat.test.ts
index 428ebaa87..f040eea80 100644
--- a/src/test/suite/dot-repeat.test.ts
+++ b/src/test/suite/dot-repeat.test.ts
@@ -14,6 +14,7 @@ import {
copyVSCodeSelection,
openTextDocument,
sendInsertKey,
+ sendVSCodeKeysAtomic,
... | [Bug] vscode-neovim runs pasted code after hitting `Esc` ???!!!
Repro Steps:
1. Create a file named `test.vim`.
2. Paste `map <leader> <cmd>call VSCodeNotifyVisual('editor.action.commentLine', 0)<cr><esc>` into the file.
3. Use VSCode to open it.
4. Enter insert mode.
5. Use `Cmd+A` to select all.
6. Use `Cmd+C... | This is the strangest bug I've seen recently, can you reproduce it? @justinmk
I've also encountered this issue and created a [pull request with the fix](https://github.com/vscode-neovim/vscode-neovim/pull/1167) a couple of weeks ago. However, the tests are failing on Windows, and I cannot investigate the reason as I d... | [
"https://github.com/vscode-neovim/vscode-neovim/commit/9a6617cb6ddc846a29d59267e6eed60d9e602ca6",
"https://github.com/vscode-neovim/vscode-neovim/commit/b94636dad773fc6f071ac8a334d62ddb77a6bb54",
"https://github.com/vscode-neovim/vscode-neovim/commit/33907455f2c5d82a005f5bb845b4e58dd69100be",
"https://github.... | 2023-03-04T14:33:33 | 0.8 | TypeScript | |
vscode-neovim/vscode-neovim | 1,439 | vscode-neovim__vscode-neovim-1439 | [
543
] | 6d225e563cb25a6f5b1299a7668df701ecca0762 | diff --git a/runtime/lua/vscode-neovim/api.lua b/runtime/lua/vscode-neovim/api.lua
index acf77b5b4..4c072e227 100644
--- a/runtime/lua/vscode-neovim/api.lua
+++ b/runtime/lua/vscode-neovim/api.lua
@@ -1,3 +1,5 @@
+local api = vim.api
+local fn = vim.fn
-- used to execute vscode command
local command_event_name = "vsc... | diff --git a/src/test/suite/jumplist.test.ts b/src/test/suite/jumping.test.ts
similarity index 74%
rename from src/test/suite/jumplist.test.ts
rename to src/test/suite/jumping.test.ts
index 3048b31f0..2739a5ad1 100644
--- a/src/test/suite/jumplist.test.ts
+++ b/src/test/suite/jumping.test.ts
@@ -1,6 +1,7 @@
import pat... | Lower-case marks lost after changes to line of mark in insert mode
**Summary**
It appears changing the buffer (e.g. `cw`) can mess up local marks.
**Steps**
Given following buffer (with cursor at `|`)
```
|Lorem ipsum dolor sit amet.
```
`ma`, `w`, `cw`, `foo`, `<esc>`, `'a`
**Actual**
```
Lorem... | I did some further debugging:
* Only marks of changed lines are affected (i.e. marks in other lines are not lost)
* Marks are only lost if entering/exiting insert mode (e.g. `cw` not `D`)
Reading debug logs and looking through the code, my best guess so far is that lines [changed](https://github.com/asvetliakov/vs... | I did some further debugging:
* Only marks of changed lines are affected (i.e. marks in other lines are not lost)
* Marks are only lost if entering/exiting insert mode (e.g. `cw` not `D`)
Reading debug logs and looking through the code, my best guess so far is that lines [changed](https://github.com/asvetliakov/vs... | [
"https://github.com/vscode-neovim/vscode-neovim/commit/04c359f5e312e996f3f0122fe6b52888f5cb014f",
"https://github.com/vscode-neovim/vscode-neovim/commit/0c942a3cf29c33943422bbbe37dcac5636483a20",
"https://github.com/vscode-neovim/vscode-neovim/commit/394d9b86f2fba5423ecacae54427e7800e232909",
"https://github.... | 2023-09-10T14:28:04 | 0.6 | TypeScript |
vscode-neovim/vscode-neovim | 2,035 | vscode-neovim__vscode-neovim-2035 | [
1752
] | fbc7c0dc4c3a21ac3c801f800844b3673a32abbd | diff --git a/src/cursor_manager.ts b/src/cursor_manager.ts
index aadacdaf5..d50e9c8e8 100644
--- a/src/cursor_manager.ts
+++ b/src/cursor_manager.ts
@@ -61,8 +61,17 @@ export class CursorManager implements Disposable {
* cursor updates while entering insert mode and insert mode commands. Thus, when those events o... | diff --git a/src/test/integ/insert-mode.test.ts b/src/test/integ/insert-mode.test.ts
index 0fd7b4736..8ac30f7a9 100644
--- a/src/test/integ/insert-mode.test.ts
+++ b/src/test/integ/insert-mode.test.ts
@@ -478,4 +478,28 @@ describe("Insert mode and buffer synchronization", () => {
client,
);
}... | [Bug] `ci'`, cursor jumps to the end of line
OS: macOS 14
nvim: 0.9.5
vscode-nvim: 1.5.0
vscode-neovim behavior (cursor jumps to the end of the line):
https://github.com/vscode-neovim/vscode-neovim/assets/28700378/238e82cd-8bfc-4e7b-a25d-1cc9b2758bde
Neovim behavior (cursor stays inside the quotes):
https... | #1080 Still can't reproduce
@xiyaowong I tried disabling all extensions except vscode-neovim, but the issue still persists.
@xiyaowong Can you share your environment info, e.g. OS, vscode version, vscode-neovim version, neovim version, etc?
OS: windows 11
All are the latest versions
@xiyaowong Can you try this on a Ma... | #1080 Still can't reproduce
@xiyaowong I tried disabling all extensions except vscode-neovim, but the issue still persists.
@xiyaowong Can you share your environment info, e.g. OS, vscode version, vscode-neovim version, neovim version, etc?
OS: windows 11
All are the latest versions
@xiyaowong Can you try this on a Ma... | [
"https://github.com/vscode-neovim/vscode-neovim/commit/96f6fc1b62ed91233cd84991d22b05c77802e027",
"https://github.com/vscode-neovim/vscode-neovim/commit/e283917ced9f5d5e3edbc3d85b454f4e767c3990"
] | 2024-05-30T14:49:13 | 1.1 | TypeScript |
vercel/ai | 8,177 | vercel__ai-8177 | [
7099
] | c4eff2967ae1cbcb1cc8fd251447c664ea9b868c | diff --git a/.changeset/long-rules-leave.md b/.changeset/long-rules-leave.md
new file mode 100644
index 000000000000..c926e2127e9f
--- /dev/null
+++ b/.changeset/long-rules-leave.md
@@ -0,0 +1,5 @@
+---
+'@ai-sdk/openai': patch
+---
+
+fix(provider/openai): correct web search tool input
diff --git a/examples/ai-core/sr... | diff --git a/packages/openai/src/responses/openai-responses-language-model.test.ts b/packages/openai/src/responses/openai-responses-language-model.test.ts
index e97ba2189eb5..0ba8d860a69f 100644
--- a/packages/openai/src/responses/openai-responses-language-model.test.ts
+++ b/packages/openai/src/responses/openai-respon... | Item 'rs_...' of type 'reasoning' was provided without its required following item
### Description
When using the `openai.responses()` API with a reasoning model, a tool call results in an error.
However, using `openai.chat()` avoids the error — but **tool calling and reasoning streaming are not available** in that ... | @lgrammel is there any hot-fix for this issue?
Hi can you check the latest ai sdk 5 beta and latest ai sdk 5 beta openai provider? we made fixes in that area
This is still happening in the latest beta releases
@lgrammel still there
```[Error [AI_APICallError]: Item 'rs_68705394944881a0bad1de4b641bb7a80d2db2349dd4408e' ... | @lgrammel is there any hot-fix for this issue?
Hi can you check the latest ai sdk 5 beta and latest ai sdk 5 beta openai provider? we made fixes in that area
This is still happening in the latest beta releases
@lgrammel still there
```[Error [AI_APICallError]: Item 'rs_68705394944881a0bad1de4b641bb7a80d2db2349dd4408e' ... | [
"https://github.com/vercel/ai/commit/8b4f1baa07f2a68af74af7325b1d6fb0d18c8f0b",
"https://github.com/vercel/ai/commit/c5013cf59d8ad9ba392009c91ad9596d0d97f891",
"https://github.com/vercel/ai/commit/5779f4b9189be954101e73d3e3b7e2c59c64de25",
"https://github.com/vercel/ai/commit/bcacb0611763f30a4f5705e5d3303b95b... | 2025-08-20T13:10:48 | 0.0 | TypeScript |
vercel/ai | 4,939 | vercel__ai-4939 | [
4920
] | 29c35b9849ac0f52c85468f055c0632b8c99fa55 | diff --git a/.changeset/few-cherries-attack.md b/.changeset/few-cherries-attack.md
new file mode 100644
index 000000000000..8d07fa1a0549
--- /dev/null
+++ b/.changeset/few-cherries-attack.md
@@ -0,0 +1,5 @@
+---
+'ai': patch
+---
+
+fix (ai/core): add `startWithReasoning` option to `extractReasoningMiddleware`
diff --g... | diff --git a/packages/ai/core/middleware/extract-reasoning-middleware.test.ts b/packages/ai/core/middleware/extract-reasoning-middleware.test.ts
index e353335b746d..72219420e209 100644
--- a/packages/ai/core/middleware/extract-reasoning-middleware.test.ts
+++ b/packages/ai/core/middleware/extract-reasoning-middleware.t... | remove stray </think> tags in reasoning extractor middleware
### Description
In some cases, the </think> tag is leaking into customer-facing messages. For example:
```
Assistant: "Okay, the user is reacting to the .... \n</think>"
```
this is most likely caused by out-of-order `<think>` and `</think>` tags. the midd... | [
"https://github.com/vercel/ai/commit/f50ce13e20d32edb128ca597c507be769fce5339",
"https://github.com/vercel/ai/commit/7d79cd07a71fa708358aece142b74edefe6596c6",
"https://github.com/vercel/ai/commit/145a1d233eee93fb171c232cbfd2417761844544",
"https://github.com/vercel/ai/commit/0c2a8b0006714829edaf54a77d7f00e1f... | 2025-02-19T13:29:30 | 0.0 | TypeScript | ||
vercel/ai | 6,925 | vercel__ai-6925 | [
6913
] | 8e6b69d42c637059176d9d92eba4738b6608b9ef | diff --git a/.changeset/spicy-bats-impress.md b/.changeset/spicy-bats-impress.md
new file mode 100644
index 000000000000..a797c4ca3874
--- /dev/null
+++ b/.changeset/spicy-bats-impress.md
@@ -0,0 +1,5 @@
+---
+'@ai-sdk/openai': major
+---
+
+fix (provider/openai): default strict mode to false
diff --git a/packages/open... | diff --git a/packages/openai/src/openai-chat-language-model.test.ts b/packages/openai/src/openai-chat-language-model.test.ts
index 3cc78cd39238..555275836746 100644
--- a/packages/openai/src/openai-chat-language-model.test.ts
+++ b/packages/openai/src/openai-chat-language-model.test.ts
@@ -545,7 +545,7 @@ describe('doG... | V5 - Tool execute() won't infer zod schema parameters
### Description
Setting up zod.object as the tool parameters result in error in the execute function.
![Image](https://github.com/user-attachments/assets/55d35a24-8880-489b-... | Yes `parameters` is now `inputSchema`. Does it work for you now? You also need to have Zod 3.25 or newer
well it does not have the type error anymore,
but im getting an error from openAI when trying to use the tool...
`{"error":{"message":"Invalid schema for function 'getAvailableTimeSlots': In context=(), 'required'... | Yes `parameters` is now `inputSchema`. Does it work for you now? You also need to have Zod 3.25 or newer
well it does not have the type error anymore,
but im getting an error from openAI when trying to use the tool...
`{"error":{"message":"Invalid schema for function 'getAvailableTimeSlots': In context=(), 'required'... | [
"https://github.com/vercel/ai/commit/bff3280cdb03fad41a4d085d165349fcb93614a7",
"https://github.com/vercel/ai/commit/c131e70daa417d4a884311c3afe7c6ec5e96c207",
"https://github.com/vercel/ai/commit/a41945570b07b8e3b3d42780fd5e418321bb2e8c",
"https://github.com/vercel/ai/commit/971516265f7a31c7f8f8a8539a9844861... | 2025-06-30T08:29:34 | 0.0 | TypeScript |
vercel/ai | 8,357 | vercel__ai-8357 | [
8180
] | b174437c4724191c5afcc07aef273440ef9fa5f0 | diff --git a/.changeset/wise-lamps-study.md b/.changeset/wise-lamps-study.md
new file mode 100644
index 000000000000..863fa6ff6445
--- /dev/null
+++ b/.changeset/wise-lamps-study.md
@@ -0,0 +1,5 @@
+---
+'@ai-sdk/google': patch
+---
+
+Fixed handling of image response in the tool call result.
diff --git a/examples/ai-c... | diff --git a/packages/google/src/convert-to-google-generative-ai-messages.test.ts b/packages/google/src/convert-to-google-generative-ai-messages.test.ts
index 4581cae8f5e0..98a65bbb6539 100644
--- a/packages/google/src/convert-to-google-generative-ai-messages.test.ts
+++ b/packages/google/src/convert-to-google-generati... | Google models can't "see" images returned from tool calls
### Description
It seems that calling`toModelOutput` when using models from `@ai-sdk/google` does not map the content properly, and the models cant "see" the images.
If I ask sonnet "Whats in this image", and it calls a tool that responds with an image, sonnet... | [
"https://github.com/vercel/ai/commit/1d22f64fbddfd97e56a3dbeff6b89771cdf8b6bd",
"https://github.com/vercel/ai/commit/7ed92c2728d05988d68563e5ae338aa4e25116f8",
"https://github.com/vercel/ai/commit/3628816e718ee2b7e643eceba44b62b45a376bf9",
"https://github.com/vercel/ai/commit/c5fcd9211237d64ac2aa2456f0e626576... | 2025-08-28T22:34:14 | 0.0 | TypeScript | ||
vercel/ai | 9,821 | vercel__ai-9821 | [
9473
] | e447eec0d2be2c44de5525ccc893abe37e244201 | diff --git a/.changeset/orange-ears-itch.md b/.changeset/orange-ears-itch.md
new file mode 100644
index 000000000000..7496895a4cbf
--- /dev/null
+++ b/.changeset/orange-ears-itch.md
@@ -0,0 +1,5 @@
+---
+'@ai-sdk/openai': patch
+---
+
+feat(openai): preserve file_id when converting file citations
diff --git a/packages/... | diff --git a/packages/openai/src/responses/__snapshots__/openai-responses-language-model.test.ts.snap b/packages/openai/src/responses/__snapshots__/openai-responses-language-model.test.ts.snap
index fd8bd1495965..bbc3b00f5047 100644
--- a/packages/openai/src/responses/__snapshots__/openai-responses-language-model.test.... | OpenAI provider: Preserve file_id when converting file citations to sources
### Description
The OpenAI responses API returns file citations with **file_id**. This information is lost when converting file citations to sources in the content array. For example https://github.com/vercel/ai/blob/27e8c3aad8e3cdd73f5d8f454c... | This would require a spec change:
https://github.com/vercel/ai/blob/0adc679a2c9c1a8b2d2af2d976666e1262dbcc59/packages/provider/src/language-model/v3/language-model-v3-source.ts#L58-L61
We'll consider it for the v6 release, as a spec change is a breaking change. Thanks!
We can store it in the provider metadata. I'll ... | This would require a spec change:
https://github.com/vercel/ai/blob/0adc679a2c9c1a8b2d2af2d976666e1262dbcc59/packages/provider/src/language-model/v3/language-model-v3-source.ts#L58-L61
We'll consider it for the v6 release, as a spec change is a breaking change. Thanks!
We can store it in the provider metadata. I'll ... | [
"https://github.com/vercel/ai/commit/c140ecbfc1b8e39697d2b1583fad925207070bae",
"https://github.com/vercel/ai/commit/a251c5bc06d075fe506b92163269b11e82cfe838",
"https://github.com/vercel/ai/commit/7b408ee6a8fe93bd674d64b991384f1281e565d3",
"https://github.com/vercel/ai/commit/ca49cf2cbaa5936248b7cfe397a1e0326... | 2025-10-27T16:33:52 | 0.0 | TypeScript |
elastic/eui | 7,156 | elastic__eui-7156 | [
7038
] | 3a653d42704d087ec285d75ab21fa51424de3b5a | diff --git a/src-docs/src/views/call_out/call_out_example.js b/src-docs/src/views/call_out/call_out_example.js
index feda7223691..97f563aceb3 100644
--- a/src-docs/src/views/call_out/call_out_example.js
+++ b/src-docs/src/views/call_out/call_out_example.js
@@ -46,6 +46,15 @@ const dangerSnippet = [
`,
];
+import On... | diff --git a/src/components/call_out/__snapshots__/call_out.test.tsx.snap b/src/components/call_out/__snapshots__/call_out.test.tsx.snap
index 0813a304ab7..da1a8e37b32 100644
--- a/src/components/call_out/__snapshots__/call_out.test.tsx.snap
+++ b/src/components/call_out/__snapshots__/call_out.test.tsx.snap
@@ -7,7 +7,... | [EuiCallOut] Add optional close button
**Is your feature request related to a problem? Please describe.**
In practice, callouts can be dismissed or closed. The current docs demonstrate the use of a 'Dismiss' button below the copy and, in Kibana, we see the use of a close button in the upper-right corner (see below).
... | @ryankeairns, my thoughts below:
**Dismissible prop**
We could add a `dismissible: bool` prop, which adds the `Dismiss` button as well as a close icon (top right).
<img width="1391" alt="Screenshot 2023-08-14 at 10 40 13" src="https://github.com/elastic/eui/assets/92029479/3e3fa0e9-7a8a-4f4b-aac7-dd38460768ea">
**::... | @ryankeairns, my thoughts below:
**Dismissible prop**
We could add a `dismissible: bool` prop, which adds the `Dismiss` button as well as a close icon (top right).
<img width="1391" alt="Screenshot 2023-08-14 at 10 40 13" src="https://github.com/elastic/eui/assets/92029479/3e3fa0e9-7a8a-4f4b-aac7-dd38460768ea">
**::... | [
"https://github.com/elastic/eui/commit/e818cfa0c645a5339860c64da578f4bb2d5dd8a9",
"https://github.com/elastic/eui/commit/a055e7903d7a81952d986e8e56c73d06579a39b2",
"https://github.com/elastic/eui/commit/bbf3fa8fcbab90231c8700f064d5c3006d43fb8a",
"https://github.com/elastic/eui/commit/0c29f6010bf8f0f98f1dd17fd... | 2023-09-05T09:55:31 | 4.5 | TypeScript |
elastic/eui | 6,883 | elastic__eui-6883 | [
6857
] | f95a3ec7594846135ad42d988d286b23fe31143f | diff --git a/src-docs/src/views/inline_edit/inline_edit_example.js b/src-docs/src/views/inline_edit/inline_edit_example.js
index 5c57e1ca5ae..ebe59fa12f2 100644
--- a/src-docs/src/views/inline_edit/inline_edit_example.js
+++ b/src-docs/src/views/inline_edit/inline_edit_example.js
@@ -30,6 +30,14 @@ const inlineEditTitl... | diff --git a/src/components/inline_edit/__snapshots__/inline_edit_form.test.tsx.snap b/src/components/inline_edit/__snapshots__/inline_edit_form.test.tsx.snap
index 752a477a9ae..73a68b09310 100644
--- a/src/components/inline_edit/__snapshots__/inline_edit_form.test.tsx.snap
+++ b/src/components/inline_edit/__snapshots_... | [EuiInlineEdit] Create `placeholder` prop for Inline Edit compoents
**Is your feature request related to a problem? Please describe.**
The inline edit pattern in Stack Management is similar to the `EuiInlineEdit` component, however, it has two display options for `readMode`. It can either:
- Display a default value t... | [
"https://github.com/elastic/eui/commit/098ee743026a461f3901f76b0b3e8b97a53c1cc1",
"https://github.com/elastic/eui/commit/dd6959f54db0c5fce340287b33f60de764273ef3",
"https://github.com/elastic/eui/commit/1c6aa7b5344d08f53675290908410ac709f53106",
"https://github.com/elastic/eui/commit/c4459c0ad58faba8edd2882a4... | 2023-06-27T19:56:49 | 4.5 | TypeScript | ||
elastic/eui | 7,301 | elastic__eui-7301 | [
7292
] | de10c6552df38f9a17d7c9e7bb7fe4171efae879 | diff --git a/src/components/datagrid/body/data_grid_row_manager.ts b/src/components/datagrid/body/data_grid_row_manager.ts
index 090f4b49365..05984951216 100644
--- a/src/components/datagrid/body/data_grid_row_manager.ts
+++ b/src/components/datagrid/body/data_grid_row_manager.ts
@@ -6,7 +6,9 @@
* Side Public License... | diff --git a/src/components/datagrid/body/data_grid_row_manager.test.ts b/src/components/datagrid/body/data_grid_row_manager.test.ts
index 8525afba21c..277d0f320ef 100644
--- a/src/components/datagrid/body/data_grid_row_manager.test.ts
+++ b/src/components/datagrid/body/data_grid_row_manager.test.ts
@@ -97,6 +97,24 @@ ... | [EuiDataGrid] When in memory sorting is enabled the grid zebra stripes do not render properly
**Describe the bug**
I have a table with one numeric and string field. When I don't sort the stripes are rendered correctly.
When I am sorting then it doesn't. Check the stripes on the second screenshot and you will see t... | [
"https://github.com/elastic/eui/commit/3db357e0a69b8bc353001c634f9060bccee64909",
"https://github.com/elastic/eui/commit/3373178d5a36fdbb82606110b6732271cda610e5",
"https://github.com/elastic/eui/commit/7b9c9e98d08edcebd2651672a2e1f699a53ab6c9",
"https://github.com/elastic/eui/commit/eae112054db0596ac012480ed... | 2023-10-20T02:49:32 | 4.5 | TypeScript | ||
elastic/eui | 7,455 | elastic__eui-7455 | [
7447
] | 154014e603d0bafdcbb937000db18055804fe1b1 | diff --git a/changelogs/upcoming/7455.md b/changelogs/upcoming/7455.md
new file mode 100644
index 00000000000..556da2a60c7
--- /dev/null
+++ b/changelogs/upcoming/7455.md
@@ -0,0 +1,1 @@
+- Updated `EuiResizableButton` to allow customizing the `indicator` style with either `handle` (default) or `border`
diff --git a/sr... | diff --git a/src/components/resizable_container/__snapshots__/resizable_button.test.tsx.snap b/src/components/resizable_container/__snapshots__/resizable_button.test.tsx.snap
index 51f2388d3a2..a6747ad44f6 100644
--- a/src/components/resizable_container/__snapshots__/resizable_button.test.tsx.snap
+++ b/src/components/... | [EuiResizableButton] Prop to switch between drag handle icon or simple border
Currently, the `EuiResizableButton` component is designed to appear like our `grab` and `grabHorizontal` icons by default. When hovering, these faux icons transition to 2px wide gray border, extending the full width/height of the parent `EuiR... | @MichaelMarcialis how do you feel about keeping the slight blue tint/halo around the border in active/focus state? i.e.,
<img width="34" alt="" src="https://github.com/elastic/eui/assets/549407/e039039e-d1c5-4833-8c09-a06b211b3a28">
I personally kind of like it for greater visibility. WDYT?
This is not a strict o... | @MichaelMarcialis how do you feel about keeping the slight blue tint/halo around the border in active/focus state? i.e.,
<img width="34" alt="" src="https://github.com/elastic/eui/assets/549407/e039039e-d1c5-4833-8c09-a06b211b3a28">
I personally kind of like it for greater visibility. WDYT?
This is not a strict o... | [
"https://github.com/elastic/eui/commit/2c0a7cce51381d2029114bbefaa687d04094a4f6",
"https://github.com/elastic/eui/commit/56121d00be072affe02cd4fe25e17012b204643d",
"https://github.com/elastic/eui/commit/b400720eac34d05abf2082ebab415bbe3f1e81c5",
"https://github.com/elastic/eui/commit/c8fd6f7b687fb4504693b128b... | 2024-01-09T23:05:06 | 4.5 | TypeScript |
elastic/eui | 7,133 | elastic__eui-7133 | [
7124
] | d08c9ab996f9531dc6cfee3418d242a4fff07537 | diff --git a/src-docs/src/views/theme/typography/_typography_js.tsx b/src-docs/src/views/theme/typography/_typography_js.tsx
index c54793b46a2..354c7c5bd34 100644
--- a/src-docs/src/views/theme/typography/_typography_js.tsx
+++ b/src-docs/src/views/theme/typography/_typography_js.tsx
@@ -1,6 +1,6 @@
import React, { Fu... | diff --git a/src/global_styling/functions/__snapshots__/typography.test.tsx.snap b/src/global_styling/functions/__snapshots__/typography.test.tsx.snap
new file mode 100644
index 00000000000..3c300bdafab
--- /dev/null
+++ b/src/global_styling/functions/__snapshots__/typography.test.tsx.snap
@@ -0,0 +1,45 @@
+// Jest Sna... | Support specifying `_FontScaleOptions` globally
**Is your feature request related to a problem? Please describe.**
I'm currently developing a browser extension. In my extension, I use Shadow DOM to isolate styles to ensure my extensions render correctly in various web environments. However, I've run into an issue th... | Labeling this as high priority and low effort. We think this would be a quick win so plan to address this shortly.
Thank you for the issue submission @y1j2x34. The EUI team is working on this in a related pull request.
| Labeling this as high priority and low effort. We think this would be a quick win so plan to address this shortly.
Thank you for the issue submission @y1j2x34. The EUI team is working on this in a related pull request.
> Thank you for the issue submission @y1j2x34. The EUI team is working on this in a related pull requ... | [
"https://github.com/elastic/eui/commit/22e8e98c9280f7c49188685b2b25940845362c98",
"https://github.com/elastic/eui/commit/79c59a65a2e75a0815c90963ca6775ee2be0f1a9",
"https://github.com/elastic/eui/commit/6e93f4413e92bbe5f7373e9a4c7531354520e837",
"https://github.com/elastic/eui/commit/648e3b23054ddba6a225fe65a... | 2023-08-28T19:41:12 | 4.5 | TypeScript |
getsentry/sentry-javascript | 15,138 | getsentry__sentry-javascript-15138 | [
15137
] | 6ba90518942fd729c9578e7a91a3ffade8b5ef34 | diff --git a/packages/node/src/integrations/anr/worker.ts b/packages/node/src/integrations/anr/worker.ts
index 8900b423710b..2eebfe40309b 100644
--- a/packages/node/src/integrations/anr/worker.ts
+++ b/packages/node/src/integrations/anr/worker.ts
@@ -46,7 +46,13 @@ async function sendAbnormalSession(): Promise<void> {
... | diff --git a/dev-packages/node-integration-tests/suites/anr/basic-session.js b/dev-packages/node-integration-tests/suites/anr/basic-session.js
index 9700131a6040..7971d547c884 100644
--- a/dev-packages/node-integration-tests/suites/anr/basic-session.js
+++ b/dev-packages/node-integration-tests/suites/anr/basic-session.... | [v9] Node ANR sessions missing `attrs.release`
### Description
Suspect this was caused by:
- https://github.com/getsentry/sentry-javascript/pull/14658
We continually pass the session to the ANR worker where it is expected to already have `attrs.release`. The session can then sent from the ANR worker later.
This was ... | [
"https://github.com/getsentry/sentry-javascript/commit/80c63a4e1942709e792cd0c4d9f7dd6ae94b1f36"
] | 2025-01-22T18:40:13 | 3.13 | TypeScript | ||
getsentry/sentry-javascript | 14,218 | getsentry__sentry-javascript-14218 | [
14158
] | a91a5ba70f36a51c486cd9acee24b1b1838ffa93 | diff --git a/packages/core/src/trpc.ts b/packages/core/src/trpc.ts
index 366a0ba9aa62..fbcdf5832b46 100644
--- a/packages/core/src/trpc.ts
+++ b/packages/core/src/trpc.ts
@@ -1,7 +1,7 @@
import { normalize } from '@sentry/utils';
-import { getClient } from './currentScopes';
-import { captureException, setContext } ... | diff --git a/dev-packages/e2e-tests/test-applications/nextjs-t3/tests/trpc-error.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-t3/tests/trpc-error.test.ts
index 0245b641db5c..d3e175e0558b 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-t3/tests/trpc-error.test.ts
+++ b/dev-packages/e2e-tests/te... | Add trpc path to context in trpcMiddleware
### Problem Statement
It would make it easier to debug if I can see which trpc route is causing an issue. The current trpc route only add procedure type and input to the context.
### Solution Brainstorm
Simply add path to trpc context in this function would likely work? htt... | So we do attach the path to spans if you have tracing enabled, but I think it also makes sense to add it as context.
would you be open to create a PR to add this?
> So we do attach the path to spans if you have tracing enabled, but I think it also makes sense to add it as context.
>
> would you be open to create a PR... | So we do attach the path to spans if you have tracing enabled, but I think it also makes sense to add it as context.
would you be open to create a PR to add this?
> So we do attach the path to spans if you have tracing enabled, but I think it also makes sense to add it as context.
>
> would you be open to create a PR... | [
"https://github.com/getsentry/sentry-javascript/commit/d2af0e1a98379efdf8bd52f0876efe1a224a9171",
"https://github.com/getsentry/sentry-javascript/commit/68999c9299ac7654c637634a20357cee719f6aab"
] | 2024-11-10T04:15:00 | 3.13 | TypeScript |
getsentry/sentry-javascript | 16,033 | getsentry__sentry-javascript-16033 | [
15965
] | d007407c2e51d93d6d3933f9dea1e03ff3f4a4ab | diff --git a/packages/react-router/src/vite/buildEnd/handleOnBuildEnd.ts b/packages/react-router/src/vite/buildEnd/handleOnBuildEnd.ts
index ce45f57a8db3..d34b5394945e 100644
--- a/packages/react-router/src/vite/buildEnd/handleOnBuildEnd.ts
+++ b/packages/react-router/src/vite/buildEnd/handleOnBuildEnd.ts
@@ -28,12 +28... | diff --git a/packages/react-router/test/vite/buildEnd/handleOnBuildEnd.test.ts b/packages/react-router/test/vite/buildEnd/handleOnBuildEnd.test.ts
index e183a4b1c14a..ace8695ec209 100644
--- a/packages/react-router/test/vite/buildEnd/handleOnBuildEnd.test.ts
+++ b/packages/react-router/test/vite/buildEnd/handleOnBuildE... | [RR7] url in unstable_sentryVitePluginOptions is ignored in React Router Vite plugin
### Is there an existing issue for this?
- [x] I have checked for existing issues https://github.com/getsentry/sentry-javascript/issues
- [x] I have reviewed the documentation https://docs.sentry.io/
- [x] I am using the latest SDK re... | Thanks for reporting! We'll fix that at some point soon-ish. For now please use the `SENTRY_URL` environment variable workaround.
| Thanks for reporting! We'll fix that at some point soon-ish. For now please use the `SENTRY_URL` environment variable workaround.
## A PR closing this issue has just been released 🚀
This issue was referenced by PR #16033, which was included in the [9.13.0 release](https://github.com/getsentry/sentry-javascript/releas... | [
"https://github.com/getsentry/sentry-javascript/commit/81030413abe78624cc6ab175a07268763ffeba71"
] | 2025-04-11T09:34:37 | 3.13 | TypeScript |
getsentry/sentry-javascript | 17,817 | getsentry__sentry-javascript-17817 | [
17804
] | e966cdc00fcecafc8aeecefca416d60efc61cfd4 | diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe9ab44858c1..358078c1fc7a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,13 @@
- "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
+### Important Changes
+
+- **fix(aws-serverless): Take `http_proxy` into account when choo... | diff --git a/packages/aws-serverless/test/init.test.ts b/packages/aws-serverless/test/init.test.ts
index 576257e3f3e4..e6a675ecc43f 100644
--- a/packages/aws-serverless/test/init.test.ts
+++ b/packages/aws-serverless/test/init.test.ts
@@ -1,6 +1,6 @@
import { getSDKSource } from '@sentry/core';
import { initWithoutDe... | Errors not sent when using an AWS lambda with a http proxy and the sentry lambda layer
### Is there an existing issue for this?
- [x] I have checked for existing issues https://github.com/getsentry/sentry-javascript/issues
- [x] I have reviewed the documentation https://docs.sentry.io/
- [x] I am using the latest SDK ... | <p><a href="https://linear.app/getsentry/issue/JS-999/errors-not-sent-when-using-an-aws-lambda-with-a-http-proxy-and-the">JS-999 Errors not sent when using an AWS lambda with a http proxy and the sentry lambda layer</a></p>
For a workaround for this I'm just using the version before [the lambda extension was turned on ... | <p><a href="https://linear.app/getsentry/issue/JS-999/errors-not-sent-when-using-an-aws-lambda-with-a-http-proxy-and-the">JS-999 Errors not sent when using an AWS lambda with a http proxy and the sentry lambda layer</a></p>
For a workaround for this I'm just using the version before [the lambda extension was turned on ... | [
"https://github.com/getsentry/sentry-javascript/commit/53e333f1b6dd90a0b678ec05061ce1f508b65d11"
] | 2025-09-29T15:45:06 | 3.13 | TypeScript |
getsentry/sentry-javascript | 11,811 | getsentry__sentry-javascript-11811 | [
11766
] | 7759d18381bd574710ff45383b51437f61d19940 | diff --git a/packages/node/src/cron/cron.ts b/packages/node/src/cron/cron.ts
index 8b6fc324a7a6..ce6225ced2fa 100644
--- a/packages/node/src/cron/cron.ts
+++ b/packages/node/src/cron/cron.ts
@@ -1,4 +1,4 @@
-import { withMonitor } from '@sentry/core';
+import { captureException, withMonitor } from '@sentry/core';
impo... | diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index 51d1eccace80..f944816fd31c 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -49,6 +49,8 @@
"mongoose": "^5.13.22",
"mysq... | node-cron and node-schedule fire checkin only on app start
### Is there an existing issue for this?
- [X] I have checked for existing issues https://github.com/getsentry/sentry-javascript/issues
- [X] I have reviewed the documentation https://docs.sentry.io/
- [X] I am using the latest SDK release https://github.com/g... | [
"https://github.com/getsentry/sentry-javascript/commit/6a5684144505c69461cf1e66eace701ae5fe7aee",
"https://github.com/getsentry/sentry-javascript/commit/f699be9af4cff17b3708cf19d0eeccf5749c4b14",
"https://github.com/getsentry/sentry-javascript/commit/2dcd126bf505d83d4ff5c6fbd4762349b5c56a47",
"https://github.... | 2024-04-26T12:45:57 | 3.13 | TypeScript | ||
getsentry/sentry-react-native | 3,727 | getsentry__sentry-react-native-3727 | [
3724
] | a5fdf556822f33677ca587bd82dbf54cc4d46e72 | diff --git a/CHANGELOG.md b/CHANGELOG.md
index e8fe8f27d8..996893e939 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@
### Fixes
- Do not enable NativeFramesTracking when native is not available ([#3705](https://github.com/getsentry/sentry-react-native/pull/3705))
+- Cancel spans in background doesn't c... | diff --git a/test/tracing/reactnativetracing.test.ts b/test/tracing/reactnativetracing.test.ts
index ce87565a22..183f963660 100644
--- a/test/tracing/reactnativetracing.test.ts
+++ b/test/tracing/reactnativetracing.test.ts
@@ -127,6 +127,13 @@ describe('ReactNativeTracing', () => {
beforeEach(() => {
jest.useFa... | Enabling Sentry.ReactNativeTracing results in Cannot read properties of undefined (reading 'remove') when sending error.
**OS:**
- [x] Windows
- [x] Linux
**Platform:**
- [ ] iOS
- [x] Android
**SDK:**
- [x] `@sentry/react-native` (>= 1.0.0)
**SDK version:** 5.19.1
**`react-native` version:** 0.73... | I have the same issue.
Hi,
thank you for the message @the-simian and @daehyeonmun2021.
I was able to reproduce this with `react-native-web`. Can you confirm it happens on the web or do you experience it also on Android or iOS with or without Expo Go?
| I have the same issue.
Hi,
thank you for the message @the-simian and @daehyeonmun2021.
I was able to reproduce this with `react-native-web`. Can you confirm it happens on the web or do you experience it also on Android or iOS with or without Expo Go?
This happens in Android on Expo Go as well as the Dev Client Buil... | [
"https://github.com/getsentry/sentry-react-native/commit/7111a1616a29b4732b3dc9b5cfbbd43bef7ca4c9"
] | 2024-04-02T09:48:42 | 0.40 | TypeScript |
getsentry/sentry-react-native | 5,081 | getsentry__sentry-react-native-5081 | [
4705
] | 21c9e756985e1b5e4c0c65d1bb24c5fa2ad6f63e | diff --git a/CHANGELOG.md b/CHANGELOG.md
index cdd58117b5..55b0eef84f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
## Unreleased
+
### Important Changes
- **fix(browser): Ensure IP address is only inferred by Relay if `sendDefaultPii` is `true`** ([#5092](https://github.com/getsentry/sentry-rea... | diff --git a/packages/core/test/tracing/timetodisplay.test.tsx b/packages/core/test/tracing/timetodisplay.test.tsx
index 43413abcbc..77b2a499a4 100644
--- a/packages/core/test/tracing/timetodisplay.test.tsx
+++ b/packages/core/test/tracing/timetodisplay.test.tsx
@@ -7,7 +7,6 @@ jest.mock('../../src/js/wrapper', () => m... | Implement TTID/TTFD as Turbo Modules
https://docs.sentry.io/platforms/react-native/tracing/instrumentation/time-to-display/
TimeToDisplay component is currently implemented as a legacy native component, and needs to be re-implemented as a turbo module the way it's done in this PR for Mask/Unmask: https://github.com/ge... | [
"https://github.com/getsentry/sentry-react-native/commit/dcf217cce9368d9f7eb2d8ae15b804bc5ae21d31",
"https://github.com/getsentry/sentry-react-native/commit/f0bf3b67ce0f68f9381f764824b2aa8344cc9bcf",
"https://github.com/getsentry/sentry-react-native/commit/bac28d566804e027f00b4b8603a8a4954b9f780b",
"https://g... | 2025-08-14T10:16:53 | 0.40 | TypeScript | ||
getsentry/sentry-react-native | 4,211 | getsentry__sentry-react-native-4211 | [
3706
] | c639edf12520d1afee79e1ff2ba18df03ce70ec3 | diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3118925cc1..ef2aade826 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,10 @@
- Enhanced accuracy of time-to-display spans. ([#4189](https://github.com/getsentry/sentry-react-native/pull/4189))
+### Features
+
+- Enables Spotlight in Android and iOS SDKs ([#4... | diff --git a/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/RNSentryModuleImplTest.kt b/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/RNSentryModuleImplTest.kt
index 5a6585ab80..f699f0d530 100644
--- a/packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/R... | Enable Spotlight in Android and iOS SDKs
### Description
At the moment Spotlight is only enabled in the JS layer of React Native. Since Android and iOS also support sending events to Spotlight we can enable the native integrations from React Native.
When Spotlight is enabled in RN, it should be automatically enabl... | [
"https://github.com/getsentry/sentry-react-native/commit/5c65d805513d1a3db7e78e6ca3ed73e6abeb797d",
"https://github.com/getsentry/sentry-react-native/commit/00f43e6e6ac12ffc48f548ec843a892b4ec42bf6",
"https://github.com/getsentry/sentry-react-native/commit/e8cf604b7773b733cc9d1cb801257f7c6cf70504",
"https://g... | 2024-10-28T17:08:23 | 0.40 | TypeScript | ||
getsentry/sentry-react-native | 2,891 | getsentry__sentry-react-native-2891 | [
2879
] | 8a53c0d7655061bf60f773f616fef53953cd3dc6 | diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9a8bd5c53b..68301d0058 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
## Unreleased
+### Fixes
+
+- Remove non URL `frame.abs_path` which was causing source maps to fail ([#2891](https://github.com/getsentry/sentry-react-native/pull/2891))
+
### Depend... | diff --git a/test/integrations/rewriteframes.test.ts b/test/integrations/rewriteframes.test.ts
new file mode 100644
index 0000000000..46fe540b9c
--- /dev/null
+++ b/test/integrations/rewriteframes.test.ts
@@ -0,0 +1,715 @@
+import type { Exception } from '@sentry/browser';
+import { defaultStackParser, eventFromExcepti... | The `abs_path` of the stack frame is `index.android.bundle` which is not a valid URL
**OS:**
- [ ] Windows
- [ ] MacOS
- [x] Linux
**Platform:**
- [ ] iOS
- [x] Android
**SDK:**
- [x] `@sentry/react-native` (>= 1.0.0)
- [ ] `react-native-sentry` (<= 0.43.2)
**SDK version:** 5.1.0
**`react-nati... | I'm seeing this as well in my react native android build.
`@sentry/react-native`: `^5.1.0`
`react-native`: `0.69.7`
hermes has also been enabled by default, which might be a factor.
My attempts at manually uploading and automatically uploading both have led to the same error.
Same here.
`@sentry/react-nativ... | I'm seeing this as well in my react native android build.
`@sentry/react-native`: `^5.1.0`
`react-native`: `0.69.7`
hermes has also been enabled by default, which might be a factor.
My attempts at manually uploading and automatically uploading both have led to the same error.
Same here.
`@sentry/react-nativ... | [
"https://github.com/getsentry/sentry-react-native/commit/6a371c4f7c0f20050c7d86fe2f081ea947d2c42b",
"https://github.com/getsentry/sentry-react-native/commit/6b5af758e02d5797559c44e47da89ed4373d54ac",
"https://github.com/getsentry/sentry-react-native/commit/2ef5ab7d76538c68d460d46a329aa1b9f627a0c5",
"https://g... | 2023-03-13T13:51:51 | 0.40 | TypeScript |
getsentry/sentry-react-native | 4,298 | getsentry__sentry-react-native-4298 | [
4121
] | e8464dbfbfde63763cb80dc920a20b8dbba04e5a | diff --git a/CHANGELOG.md b/CHANGELOG.md
index 135738a416..6e7c417a42 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@
> make sure you follow our [migration guide](https://docs.sentry.io/platforms/react-native/migration/) first.
<!-- prettier-ignore-end -->
+## Unreleased
+
+### Fixes
+
+- Remove `.sen... | diff --git a/packages/core/test/tools/metroconfig.test.ts b/packages/core/test/tools/metroconfig.test.ts
index 24135932d8..3c8a9a10b3 100644
--- a/packages/core/test/tools/metroconfig.test.ts
+++ b/packages/core/test/tools/metroconfig.test.ts
@@ -1,16 +1,5 @@
-jest.mock('fs', () => {
- return {
- readFile: jest.fn(... | Fix concurrent runs with Sentry Babel transformer
**OS:**
- [ ] Windows
- [x] MacOS
- [ ] Linux
**Platform:**
- [x] iOS
- [ ] Android
**SDK:**
- [x] `@sentry/react-native` (>= 1.0.0)
- [ ] `react-native-sentry` (<= 0.43.2)
**SDK version:** 5.30.0
**`react-native` version:** 0.72.12
**Are you using Expo?**
-... | if i comment this line. There is no error but the file can not be deleted automatically.
```
function withSentryBabelTransformer(config) {
const defaultBabelTransformerPath = config.transformer && config.transformer.babelTransformerPath;
utils_1.logger.debug('Default Babel transformer path from `config.transfor... | if i comment this line. There is no error but the file can not be deleted automatically.
```
function withSentryBabelTransformer(config) {
const defaultBabelTransformerPath = config.transformer && config.transformer.babelTransformerPath;
utils_1.logger.debug('Default Babel transformer path from `config.transfor... | [
"https://github.com/getsentry/sentry-react-native/commit/060461b34243320107770abdca8eb47bd758f5d2",
"https://github.com/getsentry/sentry-react-native/commit/30de8bcd8a81c2585c145e923898b8dcace59191"
] | 2024-11-20T17:21:18 | 0.40 | TypeScript |
h3js/h3 | 830 | h3js__h3-830 | [
705
] | c727a98ef3d5a1c1a02dbb1c2a029e7f9d4cbd12 | diff --git a/package.json b/package.json
index e140afe53..172ee2fd5 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,7 @@
"test:types": "tsc --noEmit --skipLibCheck"
},
"dependencies": {
- "cookie-es": "^1.1.0",
+ "cookie-es": "^1.2.1",
"iron-webcrypto": "^1.2.1",
"ohash": "^1.1.3",
... | diff --git a/test/cookie.test.ts b/test/cookie.test.ts
index 29535343d..e424141b9 100644
--- a/test/cookie.test.ts
+++ b/test/cookie.test.ts
@@ -80,4 +80,20 @@ describe("", () => {
expect(result.text).toBe("200");
});
});
+
+ it("can merge unique cookies", async () => {
+ ctx.app.use("/", (event) => ... | Merge set cookie value for same name multiple times
### Environment
Nuxt 3.10.3 with Nitro 2.9.1
Node 20.10.0
### Reproduction
```js
setCookie(e, 'session', '123', { httpOnly: true })
// ...
setCookie(e, 'session', '123', { httpOnly: true, maxAge: /* 1m */ 60 * 60 * 24 * 30 })
```
### Describe the bug
wil... | send only the last value, or merge the session options would be more reasonable.
Issues with merging cookies will be solved in upcoming h3 v2
| send only the last value, or merge the session options would be more reasonable.
Issues with merging cookies will be solved in upcoming h3 v2
| [
"https://github.com/h3js/h3/commit/edaebd2fb1c9cdc603497b1133cd32063af87061",
"https://github.com/h3js/h3/commit/384b868b94f0a69e4cebaceebcc690ce397cac27"
] | 2024-07-18T22:06:14 | 1.8 | TypeScript |
h3js/h3 | 368 | h3js__h3-368 | [
354
] | 03243bab1c5db92ec615fff073101114e104103c | diff --git a/src/utils/proxy.ts b/src/utils/proxy.ts
index 6e3928506..a69438135 100644
--- a/src/utils/proxy.ts
+++ b/src/utils/proxy.ts
@@ -12,6 +12,7 @@ export interface ProxyOptions {
sendStream?: boolean;
cookieDomainRewrite?: string | Record<string, string>;
cookiePathRewrite?: string | Record<string, str... | diff --git a/test/proxy.test.ts b/test/proxy.test.ts
index 3a5c458c4..6817e24b0 100644
--- a/test/proxy.test.ts
+++ b/test/proxy.test.ts
@@ -341,4 +341,75 @@ describe("", () => {
);
});
});
+
+ describe("onResponse", () => {
+ beforeEach(() => {
+ app.use(
+ "/debug",
+ eventHandle... | Add `onResponse` callback to `sendProxy` and `proxyRequest`
### Describe the feature
Sometimes it is necessary to add/modify headers for proxy response. For example, we need to add some header or remove `secure` attribute from the cookie.
I suggest to add `onResponse` callback to `sendProxy` and `proxyRequest` (si... | I think its better to upgrade `proxyRequest` to make it return modified response instead of sending response directly from method. @pi0
@oleghalin I guess by "response" you mean - to return the modified `event` (with filtered headers, modified cookies etc.)? But event is already modified after we call `sendProxy`, bec... | I think its better to upgrade `proxyRequest` to make it return modified response instead of sending response directly from method. @pi0
@oleghalin I guess by "response" you mean - to return the modified `event` (with filtered headers, modified cookies etc.)? But event is already modified after we call `sendProxy`, bec... | [
"https://github.com/h3js/h3/commit/17c3ff3f57bd602dca26d808a8163a55dd592569",
"https://github.com/h3js/h3/commit/e0dfee4cc3aeb141eeccc4a74704c9b6dbca18c4"
] | 2023-03-29T21:18:36 | 1.6 | TypeScript |
h3js/h3 | 403 | h3js__h3-403 | [
381
] | 6fd36cf40f0bf8ce3433b82af2fdae1bd1803417 | diff --git a/src/utils/body.ts b/src/utils/body.ts
index 52cd9150a..382d7b993 100644
--- a/src/utils/body.ts
+++ b/src/utils/body.ts
@@ -30,9 +30,15 @@ export function readRawBody<E extends Encoding = "utf8">(
(event.node.req as any)[RawBodySymbol] ||
(event.node.req as any).body; /* unjs/unenv #8 */
if (_... | diff --git a/test/body.test.ts b/test/body.test.ts
index 53069d97b..24e0b8774 100644
--- a/test/body.test.ts
+++ b/test/body.test.ts
@@ -194,6 +194,26 @@ describe("", () => {
expect(result.text).toBe("200");
});
+ it("handle readBody with Object type (unenv)", async () => {
+ app.use(
+ "/"... | [nuxt] [request error] [unhandled] [500] The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received an instance of Promise
### Environment
node: v16.17
nuxt: 3.4.2
nitro: 2.3.3
### Reproduction
Nuxt API requests using useAsyncData + $fetch in f... | Would you be able to provide a reproduction? 🙏
@danielroe this would be sort of a clone in terms of npm packages and env setup I have, but I cannot reproduce the issue on codesandbox. (note I have some `resolutions` on `package.json` to force some version to what I have locally)
https://codesandbox.io/p/sandbox/hell... | Would you be able to provide a reproduction? 🙏
@danielroe this would be sort of a clone in terms of npm packages and env setup I have, but I cannot reproduce the issue on codesandbox. (note I have some `resolutions` on `package.json` to force some version to what I have locally)
https://codesandbox.io/p/sandbox/hell... | [
"https://github.com/h3js/h3/commit/f382ab4cc4bd824c8e4107bf4cf6ffd91ec2e8d6",
"https://github.com/h3js/h3/commit/3703b6344ff8a7096d6046c2a5dd05d7ad190766"
] | 2023-06-09T16:23:27 | 1.7 | TypeScript |
h3js/h3 | 655 | h3js__h3-655 | [
581
] | 3a2118d4e1797a92a76443a65176ffcfaa677064 | diff --git a/docs/2.utils/2.reponse.md b/docs/2.utils/2.reponse.md
index a1b2acb9f..8342433b8 100644
--- a/docs/2.utils/2.reponse.md
+++ b/docs/2.utils/2.reponse.md
@@ -65,6 +65,35 @@ Remove a response header by name.
Directly send a response to the client.
**Note:** This function should be used only when you want to... | diff --git a/test/iteratable.test.ts b/test/iteratable.test.ts
new file mode 100644
index 000000000..43bc40771
--- /dev/null
+++ b/test/iteratable.test.ts
@@ -0,0 +1,153 @@
+import { ReadableStream } from "node:stream/web";
+import supertest, { SuperTest, Test } from "supertest";
+import { describe, it, expect, beforeE... | Support for `AsyncGenerator` event handlers, for streaming long running responses
### Describe the feature
Provide a new utility that enables developers to write streamed, chunked or partial responses using an async generator:
```typescript
async function delay<T>(ms, result:T) : Promise<T> {
return new Promi... | Seems a nice thing to support!
I'd like to help out with the PR for this. The main problem I forsee in helping to implement this is that I don't have as wide a range of experience with the ways that h3 (and nitro) are commonly used. Like, the pitfalls to avoid or defend against in the code.
Regardless, I'll get star... | Seems a nice thing to support!
I'd like to help out with the PR for this. The main problem I forsee in helping to implement this is that I don't have as wide a range of experience with the ways that h3 (and nitro) are commonly used. Like, the pitfalls to avoid or defend against in the code.
Regardless, I'll get star... | [
"https://github.com/h3js/h3/commit/251ad903036b5f5074d5a84e058e5fd3d16655bf",
"https://github.com/h3js/h3/commit/e83cbb921661a6387a8e1e579589a2966ca81587",
"https://github.com/h3js/h3/commit/e9974e72a3fbac89087d5ba3ecf084d1c7a921f5",
"https://github.com/h3js/h3/commit/f45b376bd079077b61384bb37655683ace209c4d"... | 2024-02-21T09:56:34 | 1.8 | TypeScript |
h3js/h3 | 313 | h3js__h3-313 | [
283
] | 080bf53d69b8193c4e22c873522d658dbda16656 | diff --git a/README.md b/README.md
index 3f78992a1..a6a36d2e6 100644
--- a/README.md
+++ b/README.md
@@ -110,6 +110,19 @@ app.use(eventHandler(() => '<h1>Hello world!</h1>'))
app.use('/1', eventHandler(() => '<h1>Hello world!</h1>'))
.use('/2', eventHandler(() => '<h1>Goodbye!</h1>'))
+// We can proxy requests a... | diff --git a/test/proxy.test.ts b/test/proxy.test.ts
index 721175852..3a5c458c4 100644
--- a/test/proxy.test.ts
+++ b/test/proxy.test.ts
@@ -9,6 +9,7 @@ import {
eventHandler,
getHeaders,
getMethod,
+ setHeader,
readRawBody,
setCookie,
} from "../src";
@@ -130,4 +131,214 @@ describe("", () => {
... | Add `cookieDomainRewrite`, `cookiePathRewrite` options to `sendProxy` and `proxyRequest`
### Describe the feature
Usually, when using proxy, it is necessary to rewrite `domain` and `path` attributes in `set-cookie` headers. I suggest to add `cookieDomainRewrite` and `cookiePathRewrite` options to `proxyRequest` (sim... | [
"https://github.com/h3js/h3/commit/0b9f6616bf734100e435384cc01c42361e75453d",
"https://github.com/h3js/h3/commit/0861bb416f24a2630cbe56e9aa9915238f12ed50",
"https://github.com/h3js/h3/commit/a450d8f224c79a15ed2c0322decc25802d860c7f"
] | 2023-02-05T00:03:42 | 1.6 | TypeScript | ||
web-infra-dev/rsbuild | 447 | web-infra-dev__rsbuild-447 | [
444
] | 9ffb36b75b8180cda22e5e09276482447b65e9ae | diff --git a/.changeset/orange-scissors-bathe.md b/.changeset/orange-scissors-bathe.md
new file mode 100644
index 0000000000..737429f47c
--- /dev/null
+++ b/.changeset/orange-scissors-bathe.md
@@ -0,0 +1,6 @@
+---
+'@rsbuild/shared': patch
+'@rsbuild/core': patch
+---
+
+refactor: simplify rsbuild dev-related configura... | diff --git a/e2e/cases/dev/dev.test.ts b/e2e/cases/dev/dev.test.ts
index b5895c6f97..e015c25789 100644
--- a/e2e/cases/dev/dev.test.ts
+++ b/e2e/cases/dev/dev.test.ts
@@ -16,12 +16,10 @@ test('default & hmr (default true)', async ({ page }) => {
},
plugins: [pluginReact()],
rsbuildConfig: {
- tools:... | [Feature]: simplify rsbuild dev-related configurations
### What problem does this feature solve?
There are some duplications between `dev` and `tools.devServer` configurations, and some modern.js `tools.devServer` configurations are not yet supported by rsbuild.
in modern.js：
<div style="display:flex">
<img w... | [
"https://github.com/web-infra-dev/rsbuild/commit/69ec4f723378209311820d419287ce6aa1fd01c0",
"https://github.com/web-infra-dev/rsbuild/commit/c5271a660e226ca96ae240dcbcafc4b0fb13d6d6"
] | 2023-11-10T09:29:06 | 0.0 | TypeScript | ||
web-infra-dev/rsbuild | 2,795 | web-infra-dev__rsbuild-2795 | [
2787
] | bb87515127f17154b031f787c5e13e202b78bfac | diff --git a/packages/core/src/config.ts b/packages/core/src/config.ts
index c599fa7241..bdfe236893 100644
--- a/packages/core/src/config.ts
+++ b/packages/core/src/config.ts
@@ -32,7 +32,6 @@ import {
HMR_SOCKET_PATH,
HTML_DIST_DIR,
IMAGE_DIST_DIR,
- JS_DIST_DIR,
MEDIA_DIST_DIR,
ROOT_DIST_DIR,
SVG_D... | diff --git a/packages/core/tests/__snapshots__/environments.test.ts.snap b/packages/core/tests/__snapshots__/environments.test.ts.snap
index 3fc2f52ef8..12cd899501 100644
--- a/packages/core/tests/__snapshots__/environments.test.ts.snap
+++ b/packages/core/tests/__snapshots__/environments.test.ts.snap
@@ -170,7 +170,7 ... | [Bug][1.0.0-alpha.2]: filename in multi-environments does not work
### Version
```sh
System:
OS: macOS 14.5
CPU: (10) arm64 Apple M1 Max
Memory: 131.17 MB / 32.00 GB
Shell: 5.9 - /bin/zsh
Browsers:
Chrome: 126.0.6478.127
Chrome Canary: 128.0.6573.0
Safari: 17.5
npmPackages:
... | [
"https://github.com/web-infra-dev/rsbuild/commit/9eaa102706b0d8dd8dbf9877de5d75153ac14f12",
"https://github.com/web-infra-dev/rsbuild/commit/4be463c225089a65bdf27189e6fcf06fb0d99db6"
] | 2024-07-04T07:52:58 | 0.7 | TypeScript | ||
web-infra-dev/rsbuild | 1,007 | web-infra-dev__rsbuild-1007 | [
987
] | d7ee4ff2e26ef9fd3122e7fee45dc0cbbc2b2cfa | diff --git a/packages/core/src/plugins/html.ts b/packages/core/src/plugins/html.ts
index a41f49f968..0fe7eeb821 100644
--- a/packages/core/src/plugins/html.ts
+++ b/packages/core/src/plugins/html.ts
@@ -11,6 +11,7 @@ import {
isHtmlDisabled,
removeTailSlash,
mergeChainedOptions,
+ isNil,
} from '@rsbuild/sha... | diff --git a/e2e/cases/html/inject/index.test.ts b/e2e/cases/html/inject/index.test.ts
index a22087749c..6f0e92dcfb 100644
--- a/e2e/cases/html/inject/index.test.ts
+++ b/e2e/cases/html/inject/index.test.ts
@@ -28,6 +28,8 @@ test('injection script order should be as expected', async () => {
html.indexOf('/js/conve... | [Bug]: html.inject false not works
### Version
```sh
rsbuild 0.2.5
```
### Details
I set inject false and use custom template. expect script only inject once, but actually inject twice
rsbuildConfig:
```ts
rsbuildConfig: {
html: {
inject: false,
template: './static/index.html',
... | confirmed. would you please assign to me if there's no one working on it at the moment.
> confirmed. would you please assign to me if there's no one working on it at the moment.
@xc2 Of course, thanks for your willingness to fix this~
will fix by today(+0800).
ready for review, please check
| confirmed. would you please assign to me if there's no one working on it at the moment.
> confirmed. would you please assign to me if there's no one working on it at the moment.
@xc2 Of course, thanks for your willingness to fix this~
will fix by today(+0800).
ready for review, please check
| [
"https://github.com/web-infra-dev/rsbuild/commit/8b366399e76ec81c0774f861a00a6b5f87d6cf24",
"https://github.com/web-infra-dev/rsbuild/commit/ed4bbe47a21e33b19f3aff9d63d1cda646577bc5",
"https://github.com/web-infra-dev/rsbuild/commit/a32bd4a5dbff475d29b67af260051a54ade6759e"
] | 2023-12-19T16:49:41 | 0.2 | TypeScript |
web-infra-dev/rsbuild | 729 | web-infra-dev__rsbuild-729 | [
58
] | 1fd4fa80431df89fd3e3ab35728124617ba9e605 | diff --git a/.changeset/gorgeous-swans-compete.md b/.changeset/gorgeous-swans-compete.md
new file mode 100644
index 0000000000..1e388fd4e2
--- /dev/null
+++ b/.changeset/gorgeous-swans-compete.md
@@ -0,0 +1,6 @@
+---
+'@rsbuild/shared': patch
+'@rsbuild/core': patch
+---
+
+feat(core): support printFileSize.detail and ... | diff --git a/e2e/cases/performance/printFileSize.test.ts b/e2e/cases/performance/printFileSize.test.ts
new file mode 100644
index 0000000000..46d127d506
--- /dev/null
+++ b/e2e/cases/performance/printFileSize.test.ts
@@ -0,0 +1,79 @@
+import { join } from 'path';
+import { expect, test } from '@playwright/test';
+impor... | [Feature]: Support only print total file sizes
### What problem does this feature solve?
Some users may only care about the total size, Rsbuild should support only print total file sizes,
### What does the proposed API look like?
```ts
export default {
performance: {
printFileSize: {
// whether to p... | [
"https://github.com/web-infra-dev/rsbuild/commit/beba5fa4ad8b868406f184df86c55030e7b56f34",
"https://github.com/web-infra-dev/rsbuild/commit/ea67c4b5f9f4e9b823578b0484230b861a5227d7",
"https://github.com/web-infra-dev/rsbuild/commit/ecea24b4c4ed1704b34f95d59ddcb57b3eb4fb32"
] | 2023-11-27T11:36:47 | 0.1 | TypeScript | ||
web-infra-dev/rsbuild | 4,717 | web-infra-dev__rsbuild-4717 | [
4689
] | 7354d2c9a7d39d42fce338e960b2e642a6a8e20a | diff --git a/packages/core/src/plugins/css.ts b/packages/core/src/plugins/css.ts
index 28ae9ff53b..24bf726363 100644
--- a/packages/core/src/plugins/css.ts
+++ b/packages/core/src/plugins/css.ts
@@ -1,9 +1,9 @@
-import path from 'node:path';
+import path, { posix } from 'node:path';
import deepmerge from 'deepmerge';
... | diff --git a/e2e/cases/css/export-type-string/index.test.ts b/e2e/cases/css/export-type-string/index.test.ts
new file mode 100644
index 0000000000..d8d96cbc34
--- /dev/null
+++ b/e2e/cases/css/export-type-string/index.test.ts
@@ -0,0 +1,54 @@
+import { build, dev, rspackOnlyTest } from '@e2e/helper';
+import { expect }... | [Bug]: build fails when trying to import CSS with `tools.cssLoader.exportType = 'string'`
### Version
```sh
System:
OS: Linux 6.12 Manjaro Linux
CPU: (20) x64 Intel(R) Core(TM) i5-14600K
Memory: 18.60 GB / 31.12 GB
Container: Yes
Shell: 5.9 - /usr/bin/zsh
Browsers:
Chromium: 133.0.6943.141
npmPackages:
@... | This will be supported in the next release
| This will be supported in the next release
| [
"https://github.com/web-infra-dev/rsbuild/commit/18d734980937e4668addb6485cc567b1cb827994",
"https://github.com/web-infra-dev/rsbuild/commit/ca31064512809979bab004aa102a012fc252a788",
"https://github.com/web-infra-dev/rsbuild/commit/2b6684e0332a3e5d167aafe1730975c135d22438"
] | 2025-03-06T02:53:45 | 1.0 | TypeScript |
payloadcms/payload | 14,313 | payloadcms__payload-14313 | [
14260
] | 6399635005624f399fdf766940f7b6793399f3e8 | diff --git a/packages/ui/src/elements/PublishButton/index.tsx b/packages/ui/src/elements/PublishButton/index.tsx
index 249ca17edad..fcecc28ed5e 100644
--- a/packages/ui/src/elements/PublishButton/index.tsx
+++ b/packages/ui/src/elements/PublishButton/index.tsx
@@ -170,6 +170,7 @@ export function PublishButton({ label: ... | diff --git a/test/lexical/collections/LexicalRelationships/index.ts b/test/lexical/collections/LexicalRelationships/index.ts
index c71c2c5bba8..15c51203276 100644
--- a/test/lexical/collections/LexicalRelationships/index.ts
+++ b/test/lexical/collections/LexicalRelationships/index.ts
@@ -15,6 +15,7 @@ export const Lexi... | Relationship fields expects ID instead of object in localized LexicalEditor
### Discussed in https://github.com/payloadcms/payload/discussions/14212
<div type='discussions-op-text'>
<sup>Originally posted by **Pathius** October 16, 2025</sup>
In our situation we have this `richText` field
```ts
export const introduc... | 🚀 This is included in version [v3.61.1](https://github.com/payloadcms/payload/releases/tag/v3.61.1)
This issue has been automatically locked.
Please open a new issue if this issue persists with any additional detail.
| [
"https://github.com/payloadcms/payload/commit/b093cb1584c08ad9937a2a1f9728fbcebe28b104"
] | 2025-10-23T11:19:54 | 3.0 | TypeScript | |
payloadcms/payload | 3,949 | payloadcms__payload-3949 | [
3945
] | 1f8f173741fd524c7c2f11cc104672854f625da9 | diff --git a/packages/payload/src/admin/components/forms/RenderFields/filterFields.tsx b/packages/payload/src/admin/components/forms/RenderFields/filterFields.tsx
index 472927002cd..243d6187634 100644
--- a/packages/payload/src/admin/components/forms/RenderFields/filterFields.tsx
+++ b/packages/payload/src/admin/compon... | diff --git a/test/access-control/config.ts b/test/access-control/config.ts
index be38197429e..8858f761572 100644
--- a/test/access-control/config.ts
+++ b/test/access-control/config.ts
@@ -52,7 +52,22 @@ export default buildConfigWithDefaults({
setTimeout(resolve, 50, true) // set to 'true' or 'false' here... | User with insufficient access can reassign their own roles on the front-end
### Link to reproduction
https://github.com/hdodov/payload-site/tree/bug-role-access
### Describe the Bug
A user without admin rights can *seemingly* change their own role to an admin. The front-end indicates that everything goes through suc... | This issue has been automatically locked.
Please open a new issue if this issue persists with any additional detail.
| [
"https://github.com/payloadcms/payload/commit/87376658ba21b72ed4b62dd8fca7f10f92a43610",
"https://github.com/payloadcms/payload/commit/ae4e8b511c0bffce3b33f969693d6b46da3e0e65",
"https://github.com/payloadcms/payload/commit/9b494a3c4397355c7f05a3867f5d808fadb52725",
"https://github.com/payloadcms/payload/comm... | 2023-10-31T13:57:42 | 3.0 | TypeScript | |
payloadcms/payload | 3,729 | payloadcms__payload-3729 | [
3727
] | 58e208388206f66a1543f9717a9b8685d2e5ec1d | diff --git a/packages/payload/src/graphql/schema/buildPoliciesType.ts b/packages/payload/src/graphql/schema/buildPoliciesType.ts
index 5929787fea8..999c34218fb 100644
--- a/packages/payload/src/graphql/schema/buildPoliciesType.ts
+++ b/packages/payload/src/graphql/schema/buildPoliciesType.ts
@@ -217,6 +217,9 @@ export ... | diff --git a/test/globals/config.ts b/test/globals/config.ts
index ec6f436dfbc..00686f4be3f 100644
--- a/test/globals/config.ts
+++ b/test/globals/config.ts
@@ -80,6 +80,12 @@ export default buildConfigWithDefaults({
},
],
},
+ {
+ slug: 'without-graphql',
+ access,
+ graphQL: fal... | Disabling GraphQL on a global causes Payload to generate an invalid GraphQL schema
### Link to reproduction
https://github.com/diesieben07/payload/tree/issue/disable-graphql
### To Reproduce
Set `graphQL: false` on a global
### Describe the Bug
When GraphQL is disabled, Payload generates an invalid GraphQL schema ... | This will be released in 2.0.11
This issue has been automatically locked.
Please open a new issue if this issue persists with any additional detail.
| [
"https://github.com/payloadcms/payload/commit/a1628d7901600c579866fa2c9aee6011172b1b70"
] | 2023-10-18T08:06:18 | 3.0 | TypeScript | |
payloadcms/payload | 2,438 | payloadcms__payload-2438 | [
2437
] | 95719a978c7ec088f35990db09cb80c6fcf818f5 | diff --git a/src/admin/components/views/collections/List/RelationshipProvider/index.tsx b/src/admin/components/views/collections/List/RelationshipProvider/index.tsx
index efc7c9f742e..0a77221585c 100644
--- a/src/admin/components/views/collections/List/RelationshipProvider/index.tsx
+++ b/src/admin/components/views/col... | diff --git a/test/localization/config.ts b/test/localization/config.ts
index 88fd345abb4..fda878d8381 100644
--- a/test/localization/config.ts
+++ b/test/localization/config.ts
@@ -20,7 +20,7 @@ export type LocalizedPostAllLocale = LocalizedPost & {
};
};
-export const slug = 'localized-posts';
+export const loca... | Collection List View: Relationship titles not displayed when "en" localization is not localized
### Link to reproduction
https://github.com/AlessioGr/payload/tree/repro
### To Reproduce
1. Make sure you are in the "de" locale
2. Create a document in the "Posts" and a document in the "Collection2s" collection.... | Bumping this for support, related PR is open and ready for review.
Hey @ssyberg got around to reviewing, that has been merged in! Thanks again @AlessioGr 👍
Will be released in the next version.
Woot!
This issue has been automatically locked.
Please open a new issue if this issue persists with any additional detail... | [
"https://github.com/payloadcms/payload/commit/b6f70c32c8d870ef6badaa42d3f0662b66251af3",
"https://github.com/payloadcms/payload/commit/2bfa45b31d4e6ae55d7e0e82cc5277bdd3bb16d4",
"https://github.com/payloadcms/payload/commit/977f79f2af9a79eb35f0ceff5593eeb458cd4eec",
"https://github.com/payloadcms/payload/comm... | 2023-04-02T21:03:07 | 3.0 | TypeScript | |
payloadcms/payload | 4,464 | payloadcms__payload-4464 | [
4081,
4227
] | 77ebba3ccddb806c11ab8910e0934e4f4c6aa138 | diff --git a/packages/db-mongodb/src/queries/buildSearchParams.ts b/packages/db-mongodb/src/queries/buildSearchParams.ts
index 59df2b770c6..91ca73cf45a 100644
--- a/packages/db-mongodb/src/queries/buildSearchParams.ts
+++ b/packages/db-mongodb/src/queries/buildSearchParams.ts
@@ -92,7 +92,7 @@ export async function bui... | diff --git a/test/admin/collections/Posts.ts b/test/admin/collections/Posts.ts
index 32bba0dbc5e..13c6cd7a2bb 100644
--- a/test/admin/collections/Posts.ts
+++ b/test/admin/collections/Posts.ts
@@ -15,7 +15,7 @@ export const Posts: CollectionConfig = {
},
admin: {
description: 'Description',
- listSearchab... | ID not working in listSearchableFields
### Link to reproduction
pnpm dev admin
### Describe the Bug
If `id` is included in `listSearchableFields`, the expected result is not returned.
### To Reproduce
Using the monorepo,
1. Add `id` to `listSearchableFields` in `test/admin/collections/Posts.ts`
2. `pnpm dev ad... | I've been having the same issue as in this related bug-report: [#4227](https://github.com/payloadcms/payload/issues/4227) Any updates to this?
A little extra detail:
This only seems to be an issue when searching by ID on collections whose ID's are created automatically by Payload. I have several collections where th... | I've been having the same issue as in this related bug-report: [#4227](https://github.com/payloadcms/payload/issues/4227) Any updates to this?
A little extra detail:
This only seems to be an issue when searching by ID on collections whose ID's are created automatically by Payload. I have several collections where th... | [
"https://github.com/payloadcms/payload/commit/2e1fdaf3bf4b07e53442205fd74c4ee461eb26e3",
"https://github.com/payloadcms/payload/commit/d22fe40fd86e032b50628a7e67528161708bda09"
] | 2023-12-12T17:27:47 | 3.0 | TypeScript |
TanStack/form | 501 | TanStack__form-501 | [
502
] | 665894708c4057120c10d74ee953dec293a286c9 | diff --git a/packages/form-core/src/FieldApi.ts b/packages/form-core/src/FieldApi.ts
index ff718dbe4..418719d1c 100644
--- a/packages/form-core/src/FieldApi.ts
+++ b/packages/form-core/src/FieldApi.ts
@@ -243,6 +243,7 @@ export class FieldApi<
unsubscribe()
if (!preserveValue) {
delete info.insta... | diff --git a/packages/form-core/src/tests/FieldApi.spec.ts b/packages/form-core/src/tests/FieldApi.spec.ts
index 30bfdeb3a..04698a46f 100644
--- a/packages/form-core/src/tests/FieldApi.spec.ts
+++ b/packages/form-core/src/tests/FieldApi.spec.ts
@@ -601,5 +601,9 @@ describe('field api', () => {
const info = form.ge... | Unmounting a field does not update the form
### Describe the bug
Hi,
I just noticed a bug unmounting a field: the state and fieldInfo of the field is preserved in the form even after unmounting it.
To illustrate I added some expects to the `unmount` test:
```js
// Field should have been removed from the ... | @crutchcorn can you please reopen this? seems it is not fully fixed.
| [
"https://github.com/TanStack/form/commit/28a9a4f9478e6fdede4e1b1803819331e98490ad",
"https://github.com/TanStack/form/commit/37decf8c41b3114314f8b01e489a51945a0ba048",
"https://github.com/TanStack/form/commit/008f36fa75f9e1e2b455319bef5e7adf6694bc2b",
"https://github.com/TanStack/form/commit/cc92627481c26f880... | 2023-11-02T22:00:24 | 0.0 | TypeScript | |
TanStack/form | 739 | TanStack__form-739 | [
738
] | 4879e324ec0c87c978d4276d590c680f4c8470f1 | diff --git a/packages/form-core/src/util-types.ts b/packages/form-core/src/util-types.ts
index 29f238527..25dd9f61b 100644
--- a/packages/form-core/src/util-types.ts
+++ b/packages/form-core/src/util-types.ts
@@ -60,7 +60,7 @@ type PrefixTupleAccessor<
}[TIndex]
type PrefixObjectAccessor<T extends object, TDepth ex... | diff --git a/packages/form-core/src/tests/util-types.test-d.ts b/packages/form-core/src/tests/util-types.test-d.ts
index ae07663a2..999511776 100644
--- a/packages/form-core/src/tests/util-types.test-d.ts
+++ b/packages/form-core/src/tests/util-types.test-d.ts
@@ -41,6 +41,18 @@ assertType<
| 'meta.mainUser.age'
>(... | DeepKeys type not working with all partial object
### Describe the bug
`DeepKeys` not working with all partial object, expect returns object keys, but returns `string`.
### Your minimal, reproducible example
see Steps to reproduce
### Steps to reproduce
```ts
import type { DeepKeys } from "@tanstack/react-form";
... | Thanks! Adding one more case I found with one partial nested field:
```ts
type NestedPartialObject = {
c: {
c1?: string
c2: string
}
}
// "c" | "cundefined" | "c.c1" | "c.c2"
type PartPartialObjectKeys = DeepKeys<NestedPartialObject>
```
| Thanks! Adding one more case I found with one partial nested field:
```ts
type NestedPartialObject = {
c: {
c1?: string
c2: string
}
}
// "c" | "cundefined" | "c.c1" | "c.c2"
type PartPartialObjectKeys = DeepKeys<NestedPartialObject>
```
| [
"https://github.com/TanStack/form/commit/3215e103f40bb549822ff8a0599cf5d386c1fa51"
] | 2024-06-06T10:35:01 | 0.0 | TypeScript |
TanStack/form | 1,370 | TanStack__form-1370 | [
1323
] | 527c19a5cc0ebd32da88756bf581cca1d2c2e0b5 | diff --git a/packages/form-core/src/FieldApi.ts b/packages/form-core/src/FieldApi.ts
index a95fd5515..18940ac2a 100644
--- a/packages/form-core/src/FieldApi.ts
+++ b/packages/form-core/src/FieldApi.ts
@@ -4,7 +4,12 @@ import {
standardSchemaValidators,
} from './standardSchemaValidator'
import { defaultFieldMeta }... | diff --git a/packages/form-core/tests/FieldApi.spec.ts b/packages/form-core/tests/FieldApi.spec.ts
index 9d03a23c8..a9fb317bf 100644
--- a/packages/form-core/tests/FieldApi.spec.ts
+++ b/packages/form-core/tests/FieldApi.spec.ts
@@ -62,6 +62,7 @@ describe('field api', () => {
isDirty: false,
errors: [],
... | "Cannot read properties of undefined" when removing array field
### Describe the bug
When removing elements from array using the removeFieldValue api, we sometimes receive:
```
Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'errorMap')
```
I am able to reproduce this when removing an el... | Determined that this issue actually plagues all validations post array shifting/inserting/moving/removing....
I have opened #1324 to resolve this in a much cleaner way.
I'm having the same issue.
Hope you guys like this approach, it'll allow us to fix the issue without a breaking change.
Long term we may want to upda... | Determined that this issue actually plagues all validations post array shifting/inserting/moving/removing....
I have opened #1324 to resolve this in a much cleaner way.
I'm having the same issue.
Hope you guys like this approach, it'll allow us to fix the issue without a breaking change.
Long term we may want to upda... | [
"https://github.com/TanStack/form/commit/35d3c97de8f34bdb6b03580e3981eaa8d10cc2eb"
] | 2025-04-03T00:40:35 | 0.0 | TypeScript |
TanStack/form | 475 | TanStack__form-475 | [
464
] | d739f2a064a62b71d2296766b04e8935ba93916a | diff --git a/packages/form-core/src/FormApi.ts b/packages/form-core/src/FormApi.ts
index 862e2fa2b..678267546 100644
--- a/packages/form-core/src/FormApi.ts
+++ b/packages/form-core/src/FormApi.ts
@@ -134,8 +134,10 @@ export class FormApi<TFormData, ValidatorType> {
(field) => field?.isValidating,
... | diff --git a/packages/form-core/src/tests/FormApi.spec.ts b/packages/form-core/src/tests/FormApi.spec.ts
index 9d8fdaf4f..e6ff6ba00 100644
--- a/packages/form-core/src/tests/FormApi.spec.ts
+++ b/packages/form-core/src/tests/FormApi.spec.ts
@@ -1,6 +1,7 @@
import { expect } from 'vitest'
import { FormApi } from '..... | form.Subscribe is only re-rendered if input length > 1
### Describe the bug
As soon as the input validation fails the first time, the children of form.Subscribe are only re-rendered with the correct value of `canSubmit` if the input length is longer than 1 character.
### Your minimal, reproducible example
https://... | [
"https://github.com/TanStack/form/commit/f8bc870dcf58c9c61a361a957e6a7ed0a635f527"
] | 2023-10-18T10:20:22 | 0.0 | TypeScript | ||
TanStack/form | 1,697 | TanStack__form-1697 | [
1696
] | 22c49dc8726ae8255e3e60a2a72124af46b08886 | diff --git a/.changeset/brown-cars-smell.md b/.changeset/brown-cars-smell.md
new file mode 100644
index 000000000..6532c7351
--- /dev/null
+++ b/.changeset/brown-cars-smell.md
@@ -0,0 +1,5 @@
+---
+'@tanstack/form-core': patch
+---
+
+fix(form-core): call `onSubmitInvalid` even when `canSubmit` is false
diff --git a/pa... | diff --git a/packages/form-core/tests/FormApi.spec.ts b/packages/form-core/tests/FormApi.spec.ts
index 3639ea7d6..901aa6dee 100644
--- a/packages/form-core/tests/FormApi.spec.ts
+++ b/packages/form-core/tests/FormApi.spec.ts
@@ -3156,6 +3156,32 @@ describe('form api', () => {
await form.handleSubmit()
})
+ i... | `form.onSubmitInvalid` not called when `canSubmit` is false
### Describe the bug
When `handleSubmit` is called while `canSubmit` is `false` an early return is hit and `onSubmitInvalid` is not called.
https://github.com/TanStack/form/blob/1e58e57987e4f79fb23d0034d1cdceebb9a7299b/packages/form-core/src/FormApi.ts#L1918... | [
"https://github.com/TanStack/form/commit/c70ec04778e3065bb2632b5e77b7618be1549dca",
"https://github.com/TanStack/form/commit/7a8b6b289f9401e5114a0e8ae6135358ff22544e",
"https://github.com/TanStack/form/commit/c8db95a77845fb68b79cea133758c952961252ae",
"https://github.com/TanStack/form/commit/15705d6987ac65712... | 2025-08-15T15:05:20 | 0.0 | TypeScript | ||
astral-sh/uv | 14,152 | astral-sh__uv-14152 | [
13921
] | a9a9e714819df970ccaa8af7651fa2d1f97a3672 | diff --git a/Cargo.lock b/Cargo.lock
index a30a0cbe15432..095ba90c1370c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5176,6 +5176,7 @@ dependencies = [
"uv-pypi-types",
"uv-redacted",
"uv-small-str",
+ "uv-warnings",
"version-ranges",
]
diff --git a/crates/uv-cli/src/lib.rs b/crates/uv-cli/src/lib.rs
index b... | diff --git a/crates/uv/tests/it/edit.rs b/crates/uv/tests/it/edit.rs
index d117b1e8c9f5b..59547d34b97b8 100644
--- a/crates/uv/tests/it/edit.rs
+++ b/crates/uv/tests/it/edit.rs
@@ -9364,7 +9364,7 @@ fn add_index_with_existing_relative_path_index() -> Result<()> {
let wheel_dst = packages.child("ok-1.0.0-py3-none-a... | Improve error for `--index <name>` when a name of an existing index is used
The current message (added in #13917) is:
```
error: Directory not found for index: file://path/to/index
```
We can make this more informative, particularly since the user may have intended to specify a named index instead of a URL.
| My comment on #13917 was specifically for the case where the named index exists. We might always want to error here, regardless of whether the directory exists? Or require the user to disambiguate with `./<path>`?
I'd prefer requiring something that explicitly disambiguates paths from names, such as the `./path`.
| My comment on #13917 was specifically for the case where the named index exists. We might always want to error here, regardless of whether the directory exists? Or require the user to disambiguate with `./<path>`?
I'd prefer requiring something that explicitly disambiguates paths from names, such as the `./path`.
| [
"https://github.com/astral-sh/uv/commit/e9df9bed5f82ee879384732aeb285d3a60bd0dfd",
"https://github.com/astral-sh/uv/commit/af2b605197ae39da70f39e3f50bc733f6ff62238"
] | 2025-06-20T13:53:59 | 0.4 | Rust |
astral-sh/uv | 297 | astral-sh__uv-297 | [
296
] | a4002fe13228fea2e52c1a6af77a5cccfb44c706 | diff --git a/crates/puffin-git/src/git.rs b/crates/puffin-git/src/git.rs
index ebc43b3d3014b..a2d2426c04220 100644
--- a/crates/puffin-git/src/git.rs
+++ b/crates/puffin-git/src/git.rs
@@ -15,12 +15,40 @@ use tracing::{debug, info, warn};
use url::Url;
use crate::util::retry;
-use crate::{FetchStrategy, GitReferenc... | diff --git a/crates/puffin-cli/tests/pip_compile.rs b/crates/puffin-cli/tests/pip_compile.rs
index b337dd122c275..d4d9bf90aad42 100644
--- a/crates/puffin-cli/tests/pip_compile.rs
+++ b/crates/puffin-cli/tests/pip_compile.rs
@@ -637,6 +637,168 @@ fn compile_git_https_dependency() -> Result<()> {
Ok(())
}
+/// R... | Add support for Git revision references in VCS URLs
See: https://pip.pypa.io/en/stable/topics/vcs-support. We need to support, e.g., `MyProject @ git+https://git.example.com/MyProject.git@v1.0`. I didn't realize that pip expects a different format here than Cargo, which uses query parameters.
| [
"https://github.com/astral-sh/uv/commit/5e38f45fa9ddd9f3c7e66e023ecb0769cc68fe1f"
] | 2023-11-02T18:45:49 | 0.0 | Rust | ||
astral-sh/uv | 6,585 | astral-sh__uv-6585 | [
6511
] | 6c62d9fbf1f591da0a7599f3bd8afba1110229a0 | diff --git a/crates/uv-cli/src/lib.rs b/crates/uv-cli/src/lib.rs
index b68666f2c04ae..ea67833743f9a 100644
--- a/crates/uv-cli/src/lib.rs
+++ b/crates/uv-cli/src/lib.rs
@@ -2099,11 +2099,12 @@ pub struct InitArgs {
#[arg(long)]
pub name: Option<PackageName>,
- /// Create a virtual workspace instead of a ... | diff --git a/crates/uv/tests/common/mod.rs b/crates/uv/tests/common/mod.rs
index d8e4f8daa7d88..ec187573b3189 100644
--- a/crates/uv/tests/common/mod.rs
+++ b/crates/uv/tests/common/mod.rs
@@ -1110,8 +1110,9 @@ pub fn make_project(dir: &Path, name: &str, body: &str) -> anyhow::Result<()> {
{body}
[b... | Add first-class support for virtual projects
A lot of users don't want to structure their projects as valid Python packages -- perhaps they're creating a web application, or a collection of scripts, etc. These all _can_ be structured as valid Python packages, but users tend not to do this. Requiring that projects are v... | There's an argument to be made that this should be the _default_ if you don't define a build system. I'm also open to that.
I am going to prototype this later today.
Thanks Charlie. This will definitely help users working in monorepos and legacy codebases that contain many nested packages/scripts without clear boundari... | There's an argument to be made that this should be the _default_ if you don't define a build system. I'm also open to that.
I am going to prototype this later today.
Thanks Charlie. This will definitely help users working in monorepos and legacy codebases that contain many nested packages/scripts without clear boundari... | [
"https://github.com/astral-sh/uv/commit/ecd9555c6c932565fb0967c0951b47390fa4d745",
"https://github.com/astral-sh/uv/commit/0506221dccb68de88c04dbe1a048938becd35d48"
] | 2024-08-24T16:03:38 | 0.3 | Rust |
astral-sh/uv | 4,951 | astral-sh__uv-4951 | [
4671
] | aa8f126f137a97ebe4a3887ad229409e85ea4cca | diff --git a/Cargo.lock b/Cargo.lock
index 18d0531a6d628..ae51e1cf6f060 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4475,6 +4475,7 @@ dependencies = [
"regex",
"reqwest",
"rustc-hash 2.0.0",
+ "same-file",
"serde",
"serde_json",
"textwrap",
diff --git a/crates/uv/Cargo.toml b/crates/uv/Cargo.toml
index 491... | diff --git a/crates/uv/tests/tool_install.rs b/crates/uv/tests/tool_install.rs
index 7ee1f36bfb543..798f500b323cf 100644
--- a/crates/uv/tests/tool_install.rs
+++ b/crates/uv/tests/tool_install.rs
@@ -26,7 +26,8 @@ fn tool_install() {
uv_snapshot!(context.filters(), context.tool_install()
.arg("black")
... | `uv tool` commands should warn if the executable directory isn't on the `PATH`
e.g. during `uv tool install` where the executable entry points are placed.
We can also consider some command in the style of `pipx ensurepath` that adds the executable directory the user's shell configuration.
| [
"https://github.com/astral-sh/uv/commit/b893e38f8e6f5ba050fb5d2097684dc05610bc46"
] | 2024-07-10T02:01:19 | 0.2 | Rust | ||
astral-sh/uv | 2,926 | astral-sh__uv-2926 | [
2852
] | a01143980ab4073cc31f071c7c013e027483b31b | diff --git a/crates/distribution-types/src/lib.rs b/crates/distribution-types/src/lib.rs
index 4b84e6e38a704..6c2ad6c81c458 100644
--- a/crates/distribution-types/src/lib.rs
+++ b/crates/distribution-types/src/lib.rs
@@ -371,6 +371,14 @@ impl Dist {
}
}
+ /// Returns the [`IndexUrl`], if the distribu... | diff --git a/crates/uv/tests/pip_compile.rs b/crates/uv/tests/pip_compile.rs
index 292d4507bdfe3..1f82bc1887387 100644
--- a/crates/uv/tests/pip_compile.rs
+++ b/crates/uv/tests/pip_compile.rs
@@ -7334,3 +7334,149 @@ fn compile_index_url_fallback_prefer_primary() -> Result<()> {
Ok(())
}
+
+/// Ensure that `--e... | Annotate the index from which a package is pulled in `uv pip compile`
Awaiting that #171 gets resolved, it would be very useful if `uv pip compile` could generate annotations with the “source” index.
Currently `uv pip compile --extra-index-url <MYINDEX> --no-header <(echo MYPACKAGE)` outputs something like
```
DEP... | Technically, we could do this without #171. We know which index each package comes from at compile-time.
> Technically, we could do this without #171. We know which index each package comes from at compile-time.
Sorry for my unclear wording: indeed I'm suggesting to implent this enhancement as a mitigation for possi... | Technically, we could do this without #171. We know which index each package comes from at compile-time.
> Technically, we could do this without #171. We know which index each package comes from at compile-time.
Sorry for my unclear wording: indeed I'm suggesting to implent this enhancement as a mitigation for possi... | [
"https://github.com/astral-sh/uv/commit/a068b5f9cacfe19aa8694554441905e50b4a2a38",
"https://github.com/astral-sh/uv/commit/296000fc68e5cdf236da098ac49757a98e199553",
"https://github.com/astral-sh/uv/commit/d7ef99bd3a3d7965b61cc585a8fdda707e7ac19c",
"https://github.com/astral-sh/uv/commit/da4fa226e43e1f7b6c272... | 2024-04-09T04:14:44 | 0.1 | Rust |
noir-lang/noir | 1,598 | noir-lang__noir-1598 | [
1537
] | f2d6b7bd8c909cbe85c8b5ff760ac2a4607ab56e | diff --git a/Cargo.lock b/Cargo.lock
index 1fa151a51f0..c8790acc1b1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1934,6 +1934,7 @@ dependencies = [
"noir_lsp",
"noirc_abi",
"noirc_driver",
+ "noirc_errors",
"noirc_frontend",
"predicates 2.1.5",
"rustc_version",
@@ -1997,7 +1998,6 @@ dependencies = [
"acvm... | diff --git a/crates/nargo_cli/src/cli/test_cmd.rs b/crates/nargo_cli/src/cli/test_cmd.rs
index e4fadfa41c5..ebb83bd2aa1 100644
--- a/crates/nargo_cli/src/cli/test_cmd.rs
+++ b/crates/nargo_cli/src/cli/test_cmd.rs
@@ -4,6 +4,7 @@ use acvm::{acir::native_types::WitnessMap, Backend};
use clap::Args;
use nargo::ops::exec... | Move printing errors to nargo_cli
### Problem
Currently errors are printed in noirc_driver to stdout, which is counter-intuitive for a crate that should be a library.
### Happy Case
We can move the printing of errors to `nargo_cli` instead
### Alternatives Considered
_No response_
### Additional Context
_No resp... | I will take care of it. Do I need to remove the printing from those places, right?
https://github.com/noir-lang/noir/blob/ae7ac21a796171e8e6c28b3184cc744788d9ecaa/crates/noirc_driver/src/lib.rs#L194-L200
https://github.com/noir-lang/noir/blob/ae7ac21a796171e8e6c28b3184cc744788d9ecaa/crates/noirc_driver/src/lib.rs#L... | I will take care of it. Do I need to remove the printing from those places, right?
https://github.com/noir-lang/noir/blob/ae7ac21a796171e8e6c28b3184cc744788d9ecaa/crates/noirc_driver/src/lib.rs#L194-L200
https://github.com/noir-lang/noir/blob/ae7ac21a796171e8e6c28b3184cc744788d9ecaa/crates/noirc_driver/src/lib.rs#L... | [
"https://github.com/noir-lang/noir/commit/95498ed2d03394a7b08cef8ba5bc4ac5cf8d47b2",
"https://github.com/noir-lang/noir/commit/d224e7e6cf52a569236317779109784e47389374",
"https://github.com/noir-lang/noir/commit/f687fbb20a8da7acc42dd3d44a74f51b411bec3d",
"https://github.com/noir-lang/noir/commit/0f2276778e598... | 2023-06-07T22:23:41 | 0.0 | Rust |
noir-lang/noir | 6,269 | noir-lang__noir-6269 | [
6263
] | 35dedb54a0853ba0fa85038d832a520f9ba01a98 | diff --git a/Cargo.lock b/Cargo.lock
index aca7f199bb5..936aa636e86 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2840,7 +2840,7 @@ dependencies = [
"num-bigint",
"num-traits",
"proptest",
- "proptest-derive",
+ "proptest-derive 0.4.0",
"serde",
"serde_json",
"strum",
@@ -2961,6 +2961,8 @@ dependencies = [
... | diff --git a/compiler/noirc_frontend/proptest-regressions/tests/arithmetic_generics.txt b/compiler/noirc_frontend/proptest-regressions/tests/arithmetic_generics.txt
new file mode 100644
index 00000000000..80f5c7f1ead
--- /dev/null
+++ b/compiler/noirc_frontend/proptest-regressions/tests/arithmetic_generics.txt
@@ -0,0 ... | Proptest arithmetic generics
### Problem
Arithmetic generics have gotten more complex recently and we only have a handful of unit tests to check them.
This seems insufficient since we have 5 `BinaryTypeOperator`'s, rules involving pairs of operators, and at least two conditions for simplification (`== 0` and `divide... | [
"https://github.com/noir-lang/noir/commit/4d3b48cf7dfeac261217c5ab8de10f513e901cea",
"https://github.com/noir-lang/noir/commit/7d2653caada9c1550c5a91145cb31d4f8d7f4f5e",
"https://github.com/noir-lang/noir/commit/420f94353899033188a67d5c537ab91d3b7f963e",
"https://github.com/noir-lang/noir/commit/b0ab542e08ec1... | 2024-10-10T11:42:38 | 0.0 | Rust | ||
noir-lang/noir | 7,026 | noir-lang__noir-7026 | [
6571,
7039
] | 18ea0515c47b65fa8e599cc22b1772619ae69b2e | diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 0f59de60047..d263c8245f8 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -315,7 +315,7 @@ impl<'context> Elaborator<'context> {
se... | diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index c1b86b5dcf7..637b15e7197 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -3955,3 +3955,26 @@ fn mutable_self_call() {
"#;
assert_no_errors(src);
}
+
+#[test]
+fn chec... | Traits with associated types can't be used in `where` clauses
### Aim
Given a simple trait with an associated type:
```noir
trait Foo {
type Bar;
}
```
I attempted to require `Foo` in a `where` clause in three ways:
1.
```noir
// using "where (): Foo" fails with the same error,
// even if the following impl is... | This is expected currently while the feature is incomplete - the only thing we've shipped so far is an explicit version where associated types must always be specified. So I'd expect the following to work:
```noir
fn foo<T, U>(x: T) where T: Foo<Bar = U> { }
```
(we should keep this issue until associated types are f... | This is expected currently while the feature is incomplete - the only thing we've shipped so far is an explicit version where associated types must always be specified. So I'd expect the following to work:
```noir
fn foo<T, U>(x: T) where T: Foo<Bar = U> { }
```
(we should keep this issue until associated types are f... | [
"https://github.com/noir-lang/noir/commit/555d27da71fe9a514a9528df475adcfeaf6d0c0c",
"https://github.com/noir-lang/noir/commit/ea59862a788f8332551a18d73e6ae3d74e27cfbf",
"https://github.com/noir-lang/noir/commit/f1ef945a1e1e9207d1e273526d597e9baa4a3e0d",
"https://github.com/noir-lang/noir/commit/4a59194a9848e... | 2025-01-10T18:10:34 | 0.0 | Rust |
noir-lang/noir | 7,526 | noir-lang__noir-7526 | [
7455
] | 3869fe933e5c315b57b991b5a54636c44ec3856e | diff --git a/compiler/noirc_frontend/src/ast/statement.rs b/compiler/noirc_frontend/src/ast/statement.rs
index ae7f0bef150..c44bfa6389c 100644
--- a/compiler/noirc_frontend/src/ast/statement.rs
+++ b/compiler/noirc_frontend/src/ast/statement.rs
@@ -505,7 +505,11 @@ impl PathSegment {
///
/// Returns an empty ... | diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index d758ad58d31..52f96c69c44 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -16,22 +16,16 @@ mod visibility;
// XXX: These tests repeat a lot of code
// what we should do is have... | Improve testing error locations
Right now in the compiler's frontend tests we just check that expected errors happen. However, we don't check **where** they happen.
One way to do this would be in a way similar to how it's done in parser tests:
https://github.com/noir-lang/noir/blob/8783e480a39efb47c7783c68b0e09c1c65b... | [
"https://github.com/noir-lang/noir/commit/0857654b76acdeb358cddf7f7d02ba6f12b7c8f3",
"https://github.com/noir-lang/noir/commit/7a45a29ac242f667fe931bbe1248c29d7439194e",
"https://github.com/noir-lang/noir/commit/543ccba3fa72413fa3449757057199ef37198bc5",
"https://github.com/noir-lang/noir/commit/241960af6cfcd... | 2025-02-25T23:34:03 | 0.0 | Rust | ||
noir-lang/noir | 8,097 | noir-lang__noir-8097 | [
7287
] | 28250eac56cf1717e8bea1a2bbdc75499832664b | diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 6c28a4e4af6..7c098e1a5d1 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -687,7 +687,6 @@ pub fn compile_no_check(
force_compile: bool,
) -> Result<CompiledProgram, CompileError> {
l... | diff --git a/compiler/noirc_frontend/src/ownership/tests.rs b/compiler/noirc_frontend/src/ownership/tests.rs
new file mode 100644
index 00000000000..1ba46e81053
--- /dev/null
+++ b/compiler/noirc_frontend/src/ownership/tests.rs
@@ -0,0 +1,115 @@
+#![cfg(test)]
+//! The easiest way to test this pass is a bit indirect. W... | Rework `inc_rc`, `dec_rc` and how arrays are handled in brillig in general
### Problem
`inc_rc` and `dec_rc` are a common source of bugs in SSA code generated by the compiler. They require special handling since they are effectively implicit variables attached to each array in unconstrained code.
### Happy Case
Now ... | Just to make sure I understand, you're not suggesting that `inc_rc` will disappear from the code, but rather that instead of figuring out which array it needs to act on, with the ref count being an internal part of the array in the Brillig VM, it will instead be like the length of a BoundedVec, a number passed around i... | Just to make sure I understand, you're not suggesting that `inc_rc` will disappear from the code, but rather that instead of figuring out which array it needs to act on, with the ref count being an internal part of the array in the Brillig VM, it will instead be like the length of a BoundedVec, a number passed around i... | [
"https://github.com/noir-lang/noir/commit/12f65c014e9bb265e00efcf96a73ed25d59bd796",
"https://github.com/noir-lang/noir/commit/2562ef286f515319a3506a163ffe9704b0a1d7e4",
"https://github.com/noir-lang/noir/commit/aeff5d2d956331249e9583b8fda0c1900e294edc",
"https://github.com/noir-lang/noir/commit/582a40860e882... | 2025-04-15T19:23:12 | 0.0 | Rust |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.