diff --git a/compiler-core/src/javascript.rs b/compiler-core/src/javascript.rs index 1898a030c30..cc0407e68fd 100644 --- a/compiler-core/src/javascript.rs +++ b/compiler-core/src/javascript.rs @@ -154,7 +154,19 @@ impl<'a> Generator<'a> { if self.tracker.bit_array_literal_used { self.register_prelude_usage(&mut imports, "toBitArray", None); - }; + } + + if self.tracker.bit_array_slice_used { + self.register_prelude_usage(&mut imports, "bitArraySlice", None); + } + + if self.tracker.bit_array_slice_to_float_used { + self.register_prelude_usage(&mut imports, "bitArraySliceToFloat", None); + } + + if self.tracker.bit_array_slice_to_int_used { + self.register_prelude_usage(&mut imports, "bitArraySliceToInt", None); + } if self.tracker.sized_integer_segment_used { self.register_prelude_usage(&mut imports, "sizedInt", None); @@ -786,6 +798,9 @@ pub(crate) struct UsageTracker { pub float_division_used: bool, pub object_equality_used: bool, pub bit_array_literal_used: bool, + pub bit_array_slice_used: bool, + pub bit_array_slice_to_float_used: bool, + pub bit_array_slice_to_int_used: bool, pub sized_integer_segment_used: bool, pub string_bit_array_segment_used: bool, pub codepoint_bit_array_segment_used: bool, diff --git a/compiler-core/src/javascript/expression.rs b/compiler-core/src/javascript/expression.rs index 0eb37f1cd6d..979a0aa5943 100644 --- a/compiler-core/src/javascript/expression.rs +++ b/compiler-core/src/javascript/expression.rs @@ -305,10 +305,14 @@ impl<'module> Generator<'module> { [Opt::Bits { .. }, Opt::Size { value: size, .. }] | [Opt::Size { value: size, .. }, Opt::Bits { .. }] => match &**size { TypedExpr::Int { value: size, .. } => { - Ok(docvec![value, ".slice(0, ", size, ")"]) + self.tracker.bit_array_slice_used = true; + Ok(docvec!["bitArraySlice(", value, ", 0, ", size, ")"]) } - TypedExpr::Var { name, .. } => Ok(docvec![value, ".slice(0, ", name, ")"]), + TypedExpr::Var { name, .. } => { + self.tracker.bit_array_slice_used = true; + Ok(docvec!["bitArraySlice(", value, ", 0, ", name, ")"]) + } _ => Err(Error::Unsupported { feature: "This bit array segment option".into(), @@ -1327,7 +1331,7 @@ pub(crate) fn guard_constant_expression<'a>( Constant::Var { name, .. } => Ok(assignments .iter() .find(|assignment| assignment.name == name) - .map(|assignment| assignment.subject.clone().append(assignment.path.clone())) + .map(|assignment| assignment.subject.clone()) .unwrap_or_else(|| maybe_escape_identifier_doc(name))), expression => constant_expression(Context::Function, tracker, expression), @@ -1546,7 +1550,8 @@ fn bit_array<'a>( [Opt::Bits { .. }, Opt::Size { value: size, .. }] | [Opt::Size { value: size, .. }, Opt::Bits { .. }] => match &**size { Constant::Int { value: size, .. } => { - Ok(docvec![value, ".slice(0, ", size, ")"]) + tracker.bit_array_slice_used = true; + Ok(docvec!["bitArraySlice(", value, ", 0, ", size, ")"]) } _ => Err(Error::Unsupported { diff --git a/compiler-core/src/javascript/pattern.rs b/compiler-core/src/javascript/pattern.rs index 935fa1b5145..1a843656f3e 100644 --- a/compiler-core/src/javascript/pattern.rs +++ b/compiler-core/src/javascript/pattern.rs @@ -123,6 +123,10 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' endianness: Endianness, is_signed: bool, ) { + self.expression_generator + .tracker + .bit_array_slice_to_int_used = true; + self.path.push(Index::BitArraySliceToInt { start, end, @@ -132,6 +136,10 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' } fn push_bit_array_slice_to_float(&mut self, start: usize, end: usize, endianness: Endianness) { + self.expression_generator + .tracker + .bit_array_slice_to_float_used = true; + self.path.push(Index::BitArraySliceToFloat { start, end, @@ -140,6 +148,7 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' } fn push_bit_array_slice(&mut self, start: usize, end: Option) { + self.expression_generator.tracker.bit_array_slice_used = true; self.path.push(Index::BitArraySlice(start, end)); } @@ -159,47 +168,53 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' } } - fn path_document(&self) -> Document<'a> { - concat(self.path.iter().map(|segment| match segment { - Index::Int(i) => eco_format!("[{i}]").to_doc(), - // TODO: escape string if needed - Index::String(s) => docvec![".", maybe_escape_property_doc(s)], - Index::ByteAt(i) => docvec![".byteAt(", i, ")"], - Index::BitArraySliceToInt { - start, - end, - endianness, - is_signed, - } => docvec![ - ".sliceToInt(", - start, - ", ", - end, - ", ", - bool(endianness.is_big()), - ", ", - bool(*is_signed), - ")" - ], - Index::BitArraySliceToFloat { - start, - end, - endianness, - } => docvec![ - ".sliceToFloat(", - start, - ", ", - end, - ", ", - bool(endianness.is_big()), - ")" - ], - Index::BitArraySlice(start, end) => match end { - Some(end) => docvec![".slice(", start, ", ", end, ")"], - None => docvec![".slice(", start, ")"], - }, - Index::StringPrefixSlice(i) => docvec!(".slice(", i, ")"), - })) + fn apply_path_to_subject(&self, subject: Document<'a>) -> Document<'a> { + self.path + .iter() + .fold(subject, |acc, segment| match segment { + Index::Int(i) => acc.append(eco_format!("[{i}]").to_doc()), + // TODO: escape string if needed + Index::String(s) => acc.append(docvec![".", maybe_escape_property_doc(s)]), + Index::ByteAt(i) => acc.append(docvec![".byteAt(", i, ")"]), + Index::BitArraySliceToInt { + start, + end, + endianness, + is_signed, + } => docvec![ + "bitArraySliceToInt(", + acc, + ", ", + start, + ", ", + end, + ", ", + bool(endianness.is_big()), + ", ", + bool(*is_signed), + ")" + ], + Index::BitArraySliceToFloat { + start, + end, + endianness, + } => docvec![ + "bitArraySliceToFloat(", + acc, + ", ", + start, + ", ", + end, + ", ", + bool(endianness.is_big()), + ")" + ], + Index::BitArraySlice(start, end) => match end { + Some(end) => docvec!["bitArraySlice(", acc, ", ", start, ", ", end, ")"], + None => docvec!["bitArraySlice(", acc, ", ", start, ")"], + }, + Index::StringPrefixSlice(i) => docvec!(acc, ".slice(", i, ")"), + }) } pub fn generate( @@ -407,7 +422,7 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' self.assignments .iter() .find(|assignment| assignment.name == name) - .map(|assignment| assignment.subject.clone().append(assignment.path.clone())) + .map(|assignment| assignment.subject.clone()) } pub fn traverse_pattern( @@ -531,7 +546,6 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' let var = self.next_local_var(left); self.assignments.push(Assignment { subject: expression::string(left_side_string), - path: nil(), name: left, var, }); @@ -834,52 +848,42 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' fn push_assignment(&mut self, subject: Document<'a>, name: &'a EcoString) { let var = self.next_local_var(name); - let path = self.path_document(); - self.assignments.push(Assignment { - subject, - path, - var, - name, - }); + let subject = self.apply_path_to_subject(subject); + self.assignments.push(Assignment { subject, var, name }); } fn push_string_prefix_check(&mut self, subject: Document<'a>, prefix: &'a str) { self.checks.push(Check::StringPrefix { prefix, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } fn push_booly_check(&mut self, subject: Document<'a>, expected_to_be_truthy: bool) { self.checks.push(Check::Booly { expected_to_be_truthy, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } fn push_equality_check(&mut self, subject: Document<'a>, to: Document<'a>) { self.checks.push(Check::Equal { to, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } fn push_variant_check(&mut self, subject: Document<'a>, kind: Document<'a>) { self.checks.push(Check::Variant { kind, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } fn push_result_check(&mut self, subject: Document<'a>, is_ok: bool) { self.checks.push(Check::Result { is_ok, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } @@ -892,8 +896,7 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' self.checks.push(Check::ListLength { expected_length, has_tail_spread, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } @@ -906,8 +909,7 @@ impl<'module_ctx, 'expression_gen, 'a> Generator<'module_ctx, 'expression_gen, ' self.checks.push(Check::BitArrayBitSize { expected_bit_size, tail_spread_type, - subject, - path: self.path_document(), + subject: self.apply_path_to_subject(subject), }) } } @@ -929,12 +931,11 @@ pub struct Assignment<'a> { pub name: &'a str, var: Document<'a>, pub subject: Document<'a>, - pub path: Document<'a>, } impl<'a> Assignment<'a> { pub fn into_doc(self) -> Document<'a> { - docvec!["let ", self.var, " = ", self.subject, self.path, ";"] + docvec!["let ", self.var, " = ", self.subject, ";"] } } @@ -942,39 +943,32 @@ impl<'a> Assignment<'a> { pub enum Check<'a> { Result { subject: Document<'a>, - path: Document<'a>, is_ok: bool, }, Variant { subject: Document<'a>, - path: Document<'a>, kind: Document<'a>, }, Equal { subject: Document<'a>, - path: Document<'a>, to: Document<'a>, }, ListLength { subject: Document<'a>, - path: Document<'a>, expected_length: usize, has_tail_spread: bool, }, BitArrayBitSize { subject: Document<'a>, - path: Document<'a>, expected_bit_size: usize, tail_spread_type: Option, }, StringPrefix { subject: Document<'a>, - path: Document<'a>, prefix: &'a str, }, Booly { subject: Document<'a>, - path: Document<'a>, expected_to_be_truthy: bool, }, Guard { @@ -996,47 +990,37 @@ impl<'a> Check<'a> { Check::Booly { expected_to_be_truthy, subject, - path, } => { if expected_to_be_truthy == match_desired { - docvec![subject, path] + subject } else { - docvec!["!", subject, path] + docvec!["!", subject] } } - Check::Variant { - subject, - path, - kind, - } => { + Check::Variant { subject, kind } => { if match_desired { - docvec![subject, path, " instanceof ", kind] + docvec![subject, " instanceof ", kind] } else { - docvec!["!(", subject, path, " instanceof ", kind, ")"] + docvec!["!(", subject, " instanceof ", kind, ")"] } } - Check::Result { - subject, - path, - is_ok, - } => { + Check::Result { subject, is_ok } => { if match_desired == is_ok { - docvec![subject, path, ".isOk()"] + docvec![subject, ".isOk()"] } else { - docvec!["!", subject, path, ".isOk()"] + docvec!["!", subject, ".isOk()"] } } - Check::Equal { subject, path, to } => { + Check::Equal { subject, to } => { let operator = if match_desired { " === " } else { " !== " }; - docvec![subject, path, operator, to] + docvec![subject, operator, to] } Check::ListLength { subject, - path, expected_length, has_tail_spread, } => { @@ -1046,18 +1030,17 @@ impl<'a> Check<'a> { eco_format!(".hasLength({expected_length})").to_doc() }; if match_desired { - docvec![subject, path, length_check,] + docvec![subject, length_check,] } else { - docvec!["!", subject, path, length_check,] + docvec!["!", subject, length_check,] } } Check::BitArrayBitSize { subject, - path, expected_bit_size, tail_spread_type, } => { - let bit_size = docvec![subject.clone(), path.clone(), ".bitSize"]; + let bit_size = docvec![subject.clone(), ".bitSize"]; let bit_size_check = match tail_spread_type { Some(BitArrayTailSpreadType::Bits) => { @@ -1088,16 +1071,12 @@ impl<'a> Check<'a> { docvec!["!(", bit_size_check, ")"] } } - Check::StringPrefix { - subject, - path, - prefix, - } => { + Check::StringPrefix { subject, prefix } => { let prefix = expression::string(prefix); if match_desired { - docvec![subject, path, ".startsWith(", prefix, ")"] + docvec![subject, ".startsWith(", prefix, ")"] } else { - docvec!["!", subject, path, ".startsWith(", prefix, ")"] + docvec!["!", subject, ".startsWith(", prefix, ")"] } } } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__as_module_const.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__as_module_const.snap index 953a9112c38..dbd74299806 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__as_module_const.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__as_module_const.snap @@ -24,7 +24,7 @@ expression: "\n pub const data = <<\n 0x1,\n 2,\n ----- COMPILED JAVASCRIPT -import { toBitArray, sizedInt, stringBits, sizedFloat } from "../gleam.mjs"; +import { toBitArray, bitArraySlice, sizedInt, stringBits, sizedFloat } from "../gleam.mjs"; export const data = /* @__PURE__ */ toBitArray([ 1, @@ -35,7 +35,7 @@ export const data = /* @__PURE__ */ toBitArray([ stringBits("Gleam"), sizedFloat(4.2, 64, true), sizedFloat(4.2, 32, true), - /* @__PURE__ */ toBitArray([250]).slice(0, 6), + bitArraySlice(/* @__PURE__ */ toBitArray([250]), 0, 6), sizedInt(-1, 64, true), /* @__PURE__ */ toBitArray([ /* @__PURE__ */ toBitArray([1, 2, 3]), diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_dynamic_slice.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_dynamic_slice.snap index d874f6dd2df..acc5851b571 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_dynamic_slice.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_dynamic_slice.snap @@ -11,9 +11,9 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { toBitArray } from "../gleam.mjs"; +import { toBitArray, bitArraySlice } from "../gleam.mjs"; function go(x) { let i = 4; - return toBitArray([toBitArray([171]).slice(0, i)]); + return toBitArray([bitArraySlice(toBitArray([171]), 0, i)]); } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_literal_string_pattern_is_treated_as_utf8.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_literal_string_pattern_is_treated_as_utf8.snap index b76057866cf..b2609fc18ba 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_literal_string_pattern_is_treated_as_utf8.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_literal_string_pattern_is_treated_as_utf8.snap @@ -12,7 +12,7 @@ pub fn main() { } ----- COMPILED JAVASCRIPT -import { toBitArray } from "../gleam.mjs"; +import { toBitArray, bitArraySlice } from "../gleam.mjs"; export function main() { let $ = toBitArray([]); diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_sliced.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_sliced.snap index 4b9c056ba0f..68f137b76b8 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_sliced.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__bit_array_sliced.snap @@ -10,8 +10,8 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { toBitArray } from "../gleam.mjs"; +import { toBitArray, bitArraySlice } from "../gleam.mjs"; function go(x) { - return toBitArray([toBitArray([171]).slice(0, 4)]); + return toBitArray([bitArraySlice(toBitArray([171]), 0, 4)]); } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__discard_sized.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__discard_sized.snap index 3b98e8034dc..efded82c0c2 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__discard_sized.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__discard_sized.snap @@ -11,7 +11,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 24)) { diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_binary_size.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_binary_size.snap index 2c3a94dcd85..87bbe1f694f 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_binary_size.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_binary_size.snap @@ -11,7 +11,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySlice } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 24)) { @@ -24,7 +24,7 @@ function go(x) { { value: x } ) } - let a = x.slice(8, 24); + let a = bitArraySlice(x, 8, 24); if (!(x.bitSize == 24)) { throw makeError( "let_assert", @@ -35,6 +35,6 @@ function go(x) { { value: x } ) } - let b = x.slice(8, 24); + let b = bitArraySlice(x, 8, 24); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bits_with_size.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bits_with_size.snap index 030761c5348..04d2dece62d 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bits_with_size.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bits_with_size.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError, toBitArray, sizedInt } from "../gleam.mjs"; +import { makeError, toBitArray, bitArraySlice, bitArraySliceToInt, sizedInt } from "../gleam.mjs"; function go(x) { let $ = toBitArray([sizedInt(0x77, 7, true)]); @@ -24,6 +24,6 @@ function go(x) { { value: $ } ) } - let f = $.slice(4, 6); + let f = bitArraySlice($, 4, 6); return $; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bytes_with_size.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bytes_with_size.snap index 6fa594a44ce..85b4f1032d0 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bytes_with_size.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_bytes_with_size.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError, toBitArray } from "../gleam.mjs"; +import { makeError, toBitArray, bitArraySlice } from "../gleam.mjs"; function go(x) { let $ = toBitArray([1, 2]); @@ -24,6 +24,6 @@ function go(x) { { value: $ } ) } - let f = $.slice(0, 16); + let f = bitArraySlice($, 0, 16); return $; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float.snap index 84e068236c5..8249e7c7799 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToFloat } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 72)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToFloat(0, 64, true); + let a = bitArraySliceToFloat(x, 0, 64, true); let b = x.byteAt(8); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_big_endian.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_big_endian.snap index b7788ce7cab..6f8bb5471b5 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_big_endian.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_big_endian.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToFloat } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 72)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToFloat(0, 64, true); + let a = bitArraySliceToFloat(x, 0, 64, true); let b = x.byteAt(8); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_little_endian.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_little_endian.snap index fc1f5c6dd74..32b7fc26911 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_little_endian.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_little_endian.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToFloat } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 72)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToFloat(0, 64, false); + let a = bitArraySliceToFloat(x, 0, 64, false); let b = x.byteAt(8); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized.snap index 1af61a249db..9c2ee180909 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToFloat } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 40)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToFloat(0, 32, true); + let a = bitArraySliceToFloat(x, 0, 32, true); let b = x.byteAt(4); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_big_endian.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_big_endian.snap index ea91b34ccb9..d5f63bfb42e 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_big_endian.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_big_endian.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToFloat } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 40)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToFloat(0, 32, true); + let a = bitArraySliceToFloat(x, 0, 32, true); let b = x.byteAt(4); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_little_endian.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_little_endian.snap index 8059c494d4d..20140072e26 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_little_endian.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_float_sized_little_endian.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToFloat } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 40)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToFloat(0, 32, false); + let a = bitArraySliceToFloat(x, 0, 32, false); let b = x.byteAt(4); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest.snap index df0676a15f9..6420d57967f 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError, toBitArray } from "../gleam.mjs"; +import { makeError, toBitArray, bitArraySlice } from "../gleam.mjs"; function go(x) { let $ = toBitArray([1, 2, 3]); @@ -24,6 +24,6 @@ function go(x) { { value: $ } ) } - let b = $.slice(8); + let b = bitArraySlice($, 8); return $; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits.snap index e665be65224..b2b9b93ba59 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError, toBitArray } from "../gleam.mjs"; +import { makeError, toBitArray, bitArraySlice } from "../gleam.mjs"; function go(x) { let $ = toBitArray([1, 2, 3]); @@ -24,6 +24,6 @@ function go(x) { { value: $ } ) } - let b = $.slice(8); + let b = bitArraySlice($, 8); return $; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits_unaligned.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits_unaligned.snap index b50e2889fcf..261e22f492f 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits_unaligned.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bits_unaligned.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError, toBitArray } from "../gleam.mjs"; +import { makeError, toBitArray, bitArraySlice, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { let $ = toBitArray([1, 2, 3]); @@ -24,6 +24,6 @@ function go(x) { { value: $ } ) } - let b = $.slice(5); + let b = bitArraySlice($, 5); return $; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bytes.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bytes.snap index df0676a15f9..6420d57967f 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bytes.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_rest_bytes.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError, toBitArray } from "../gleam.mjs"; +import { makeError, toBitArray, bitArraySlice } from "../gleam.mjs"; function go(x) { let $ = toBitArray([1, 2, 3]); @@ -24,6 +24,6 @@ function go(x) { { value: $ } ) } - let b = $.slice(8); + let b = bitArraySlice($, 8); return $; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_signed.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_signed.snap index 4496ab86f75..3348365782e 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_signed.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_signed.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 8)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 8, true, true); + let a = bitArraySliceToInt(x, 0, 8, true, true); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized.snap index 672c6383f00..4104bf55975 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 24)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, true, false); + let a = bitArraySliceToInt(x, 0, 16, true, false); let b = x.byteAt(2); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian.snap index b74e704ec20..05d9ace8905 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, true, false); + let a = bitArraySliceToInt(x, 0, 16, true, false); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_signed.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_signed.snap index a3721d0447c..78924502d1c 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_signed.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_signed.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, true, true); + let a = bitArraySliceToInt(x, 0, 16, true, true); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_unsigned.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_unsigned.snap index cc16bbdba97..9b620b8189f 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_unsigned.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_big_endian_unsigned.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, true, false); + let a = bitArraySliceToInt(x, 0, 16, true, false); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian.snap index 23b7b248faf..c69b97fa56f 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, false, false); + let a = bitArraySliceToInt(x, 0, 16, false, false); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_signed.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_signed.snap index d490255f9a6..02ac68e778a 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_signed.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_signed.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, false, true); + let a = bitArraySliceToInt(x, 0, 16, false, true); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_unsigned.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_unsigned.snap index 6c1f85715ef..89dfbda8ba8 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_unsigned.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_little_endian_unsigned.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 16, false, false); + let a = bitArraySliceToInt(x, 0, 16, false, false); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_unaligned.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_unaligned.snap index f3b1b707726..5b785a360b2 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_unaligned.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_unaligned.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 24)) { @@ -23,7 +23,7 @@ function go(x) { { value: x } ) } - let a = x.sliceToInt(0, 17, true, false); - let b = x.sliceToInt(17, 24, true, false); + let a = bitArraySliceToInt(x, 0, 17, true, false); + let b = bitArraySliceToInt(x, 17, 24, true, false); return x; } diff --git a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_value.snap b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_value.snap index a1507329fa2..87d6e894f1e 100644 --- a/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_value.snap +++ b/compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__bit_arrays__match_sized_value.snap @@ -10,7 +10,7 @@ fn go(x) { ----- COMPILED JAVASCRIPT -import { makeError } from "../gleam.mjs"; +import { makeError, bitArraySliceToInt } from "../gleam.mjs"; function go(x) { if (!(x.bitSize == 16)) { @@ -23,6 +23,6 @@ function go(x) { { value: x } ) } - let i = x.sliceToInt(0, 16, true, false); + let i = bitArraySliceToInt(x, 0, 16, true, false); return x; } diff --git a/compiler-core/templates/prelude.d.mts b/compiler-core/templates/prelude.d.mts index 77cc17edcad..01f1156bf61 100644 --- a/compiler-core/templates/prelude.d.mts +++ b/compiler-core/templates/prelude.d.mts @@ -34,15 +34,6 @@ export class BitArray { /** @internal */ equals(other: BitArray): boolean; - /** @internal */ - slice(start: number, end: number): BitArray; - - /** @internal */ - sliceToFloat(start: number, end: number, isBigEndian: boolean): number; - - /** @internal */ - sliceToInt(start: number, end: number, isBigEndian: boolean, isSigned: boolean): number; - /** @deprecated */ get buffer(): Uint8Array; diff --git a/compiler-core/templates/prelude.mjs b/compiler-core/templates/prelude.mjs index 8b10137ffb9..7c94e08f632 100644 --- a/compiler-core/templates/prelude.mjs +++ b/compiler-core/templates/prelude.mjs @@ -261,21 +261,6 @@ export class BitArray { return true; } - /** @internal */ - slice(start, end) { - return bitArraySlice(this, start, end); - } - - /** @internal */ - sliceToFloat(start, end, isBigEndian) { - return bitArraySliceToFloat(this, start, end, isBigEndian); - } - - /** @internal */ - sliceToInt(start, end, isBigEndian, isSigned) { - return bitArraySliceToInt(this, start, end, isBigEndian, isSigned); - } - /** * Returns this bit array's internal buffer. * @@ -373,7 +358,7 @@ function bitArrayPrintDeprecationWarning(name, message) { * @param {number} [end] * @returns {BitArray} */ -function bitArraySlice(bitArray, start, end) { +export function bitArraySlice(bitArray, start, end) { end ??= bitArray.bitSize; bitArrayValidateRange(bitArray, start, end); @@ -425,7 +410,7 @@ function bitArraySlice(bitArray, start, end) { * @param {boolean} isBigEndian * @returns {number} */ -function bitArraySliceToFloat(bitArray, start, end, isBigEndian) { +export function bitArraySliceToFloat(bitArray, start, end, isBigEndian) { bitArrayValidateRange(bitArray, start, end); const floatSize = end - start; @@ -488,7 +473,7 @@ function bitArraySliceToFloat(bitArray, start, end, isBigEndian) { * @param {boolean} isSigned * @returns {number} */ -function bitArraySliceToInt(bitArray, start, end, isBigEndian, isSigned) { +export function bitArraySliceToInt(bitArray, start, end, isBigEndian, isSigned) { bitArrayValidateRange(bitArray, start, end); if (start === end) { diff --git a/test/javascript_prelude/main.mjs b/test/javascript_prelude/main.mjs index 737c03a7f72..06da27e5198 100755 --- a/test/javascript_prelude/main.mjs +++ b/test/javascript_prelude/main.mjs @@ -14,6 +14,9 @@ import { toList, sizedInt, sizedFloat, + bitArraySlice, + bitArraySliceToInt, + bitArraySliceToFloat, } from "./prelude.mjs"; let failures = 0; @@ -534,89 +537,103 @@ assertNotEqual(hasEqualsField, hasEqualsField2); assertEqual(new BitArray(new Uint8Array([1, 2, 3])).byteAt(0), 1); assertEqual(new BitArray(new Uint8Array([1, 2, 3])).byteAt(2), 3); -// BitArray.slice() +// bitArraySlice -assertThrows("`BitArray.slice()` throws if start is less than zero", () => - new BitArray(new Uint8Array([1])).slice(-1, 8), +assertThrows("`bitArraySlice()` throws if start is less than zero", () => + bitArraySlice(new BitArray(new Uint8Array([1])), -1, 8), ); assertThrows( - "`BitArray.slice()` throws if start is greater than the bit size", - () => new BitArray(new Uint8Array([1])).slice(9, 8), + "`bitArraySlice()` throws if start is greater than the bit size", + () => bitArraySlice(new BitArray(new Uint8Array([1])), 9, 8), ); -assertThrows("`BitArray.slice()` throws if end is before start", () => - new BitArray(new Uint8Array([1])).slice(4, 2), +assertThrows("`bitArraySlice()` throws if end is before start", () => + bitArraySlice(new BitArray(new Uint8Array([1])), 4, 2), ); assertThrows( - "`BitArray.slice()` throws if end is greater than the bit size", - () => new BitArray(new Uint8Array([1])).slice(0, 10), + "`bitArraySlice()` throws if end is greater than the bit size", + () => bitArraySlice(new Uint8Array([1]), 0, 10), ); assertEqual( - new BitArray(new Uint8Array([1, 2, 3])).slice(0, 0), + bitArraySlice(new BitArray(new Uint8Array([1, 2, 3])), 0, 0), new BitArray(new Uint8Array([])), ); assertEqual( - new BitArray(new Uint8Array([0xbe, 0xff])).slice(0, 2), + bitArraySlice(new BitArray(new Uint8Array([0xbe, 0xff])), 0, 2), new BitArray(new Uint8Array([0xbe]), 2), ); assertEqual( - new BitArray(new Uint8Array([0x12, 0b10101101, 0xff])).slice(10, 14), + bitArraySlice(new BitArray(new Uint8Array([0x12, 0b10101101, 0xff])), 10, 14), new BitArray(new Uint8Array([0b10110100]), 4), ); assertEqual( - new BitArray(new Uint8Array([1, 2, 3])).slice(8, 24), + bitArraySlice(new BitArray(new Uint8Array([1, 2, 3])), 8, 24), new BitArray(new Uint8Array([2, 3])), ); assertEqual( - new BitArray(new Uint8Array([1, 2, 3, 4, 5])).slice(8, 32), + bitArraySlice(new BitArray(new Uint8Array([1, 2, 3, 4, 5])), 8, 32), new BitArray(new Uint8Array([2, 3, 4])), ); assertEqual( - new BitArray(new Uint8Array([1, 0xfe, 0xa1])).slice(8, 19), + bitArraySlice(new BitArray(new Uint8Array([1, 0xfe, 0xa1])), 8, 19), new BitArray(new Uint8Array([0xfe, 0xa1]), 11), ); assertEqual( - new BitArray(new Uint8Array([17, 79, 190, 151, 98, 222, 101])).slice(19, 51), + bitArraySlice( + new BitArray(new Uint8Array([17, 79, 190, 151, 98, 222, 101])), + 19, + 51, + ), new BitArray(new Uint8Array([244, 187, 22, 243]), 32), ); assertEqual( - new BitArray(new Uint8Array([0, 0, 0, 0, 0xff, 0xe0])).slice(37, 41), + bitArraySlice(new BitArray(new Uint8Array([0, 0, 0, 0, 0xff, 0xe0])), 37, 41), new BitArray(new Uint8Array([0b11111100]), 4), ); assertEqual( - new BitArray(new Uint8Array([0xaa, 0xbb, 0xff, 0, 0, 0])) - .slice(8, 48) - .sliceToFloat(8, 40, false), + bitArraySliceToFloat( + bitArraySlice( + new BitArray(new Uint8Array([0xaa, 0xbb, 0xff, 0, 0, 0])), + 8, + 48, + ), + 8, + 40, + false, + ), 3.5733110840282835e-43, ); assertEqual( - new BitArray(new Uint8Array([1, 2, 3, 4, 5])).slice(8, 32).slice(8), + bitArraySlice( + bitArraySlice(new BitArray(new Uint8Array([1, 2, 3, 4, 5])), 8, 32), + 8, + ), new BitArray(new Uint8Array([3, 4])), ); assertEqual( - new BitArray( - new Uint8Array([0b00000001, 0b00000010, 0b00000011]), - 20, - 2, - ).slice(4, 10), + bitArraySlice( + new BitArray(new Uint8Array([0b00000001, 0b00000010, 0b00000011]), 20, 2), + 4, + 10, + ), new BitArray(new Uint8Array([0b00000001, 0b00000010]), 6, 6), ); assertEqual( - new BitArray(new Uint8Array([1])).slice(1), + bitArraySlice(new BitArray(new Uint8Array([1])), 1), new BitArray(new Uint8Array([0b00000010]), 7), ); @@ -702,54 +719,65 @@ assertEqual( new BitArray(new Uint8Array([255, 255, 255, 255, 255, 248, 0, 0, 0, 0]), 75), ); -// BitArray.sliceToFloat() +// bitArraySliceToFloat() assertEqual( - toBitArray([63, 240, 0, 0, 0, 0, 0, 0]).sliceToFloat(0, 64, true), + bitArraySliceToFloat(toBitArray([63, 240, 0, 0, 0, 0, 0, 0]), 0, 64, true), 1.0, ); assertEqual( - toBitArray([0, 0, 0, 0, 0, 0, 240, 63]).sliceToFloat(0, 64, false), + bitArraySliceToFloat(toBitArray([0, 0, 0, 0, 0, 0, 240, 63]), 0, 64, false), 1.0, ); assertEqual( - toBitArray([0xff, 0xc9, 0x74, 0x24, 0x00]).sliceToFloat(8, 40, true), + bitArraySliceToFloat(toBitArray([0xff, 0xc9, 0x74, 0x24, 0x00]), 8, 40, true), -1000000.0, ); assertEqual( - toBitArray([0x00, 0x24, 0x74, 0xc9]).sliceToFloat(0, 32, false), + bitArraySliceToFloat(toBitArray([0x00, 0x24, 0x74, 0xc9]), 0, 32, false), -1000000.0, ); assertEqual( - new BitArray( - new Uint8Array([112, 152, 127, 244, 0, 7, 192]), - 50, - 0, - ).sliceToFloat(11, 43, true), + bitArraySliceToFloat( + new BitArray(new Uint8Array([112, 152, 127, 244, 0, 7, 192]), 50, 0), + 11, + 43, + true, + ), -511.25, ); assertEqual( - new BitArray( - new Uint8Array([8, 0, 0, 0, 1, 129, 39, 103, 129, 254]), - 79, - 0, - ).sliceToFloat(7, 71, false), + bitArraySliceToFloat( + new BitArray( + new Uint8Array([8, 0, 0, 0, 1, 129, 39, 103, 129, 254]), + 79, + 0, + ), + 7, + 71, + false, + ), -5011.75, ); assertEqual( - new BitArray( - new Uint8Array([212, 152, 127, 244, 0, 7, 192]), - 50, - 3, - ).sliceToFloat(11, 43, true), + bitArraySliceToFloat( + new BitArray(new Uint8Array([212, 152, 127, 244, 0, 7, 192]), 50, 3), + 11, + 43, + true, + ), 1.0714967429001753e-19, ); -// BitArray.sliceToInt() +// bitArraySliceToInt() -assertEqual(toBitArray([0b10011110]).sliceToInt(0, 4, true, false), 0b1001); assertEqual( - new BitArray(new Uint8Array([0b11001110]), 7, 1).sliceToInt( + bitArraySliceToInt(toBitArray([0b10011110]), 0, 4, true, false), + 0b1001, +); +assertEqual( + bitArraySliceToInt( + new BitArray(new Uint8Array([0b11001110]), 7, 1), 0, 4, true, @@ -757,12 +785,22 @@ assertEqual( ), 0b1001, ); -assertEqual(toBitArray([0b10011110]).sliceToInt(4, 8, true, false), 0b1110); -assertEqual(toBitArray([0b10011110]).sliceToInt(1, 6, true, true), 0b00111); -assertEqual(toBitArray([0b10011010]).sliceToInt(3, 8, true, true), -6); -assertEqual(toBitArray([0b10011010]).sliceToInt(0, 7, true, true), -51); assertEqual( - new BitArray(new Uint8Array([0b11001100, 0b00100000]), 11).sliceToInt( + bitArraySliceToInt(toBitArray([0b10011110]), 4, 8, true, false), + 0b1110, +); +assertEqual( + bitArraySliceToInt(toBitArray([0b10011110]), 1, 6, true, true), + 0b00111, +); +assertEqual(bitArraySliceToInt(toBitArray([0b10011010]), 3, 8, true, true), -6); +assertEqual( + bitArraySliceToInt(toBitArray([0b10011010]), 0, 7, true, true), + -51, +); +assertEqual( + bitArraySliceToInt( + new BitArray(new Uint8Array([0b11001100, 0b00100000]), 11), 1, 11, false, @@ -770,37 +808,59 @@ assertEqual( ), 408, ); -assertEqual(toBitArray([0xb6, 0xe3]).sliceToInt(0, 12, true, false), 0xb6e); -assertEqual(toBitArray([0xb6, 0xe3]).sliceToInt(0, 12, false, false), 0xeb6); assertEqual( - toBitArray([0xff, 0xb6, 0xe3]).sliceToInt(8, 20, true, false), + bitArraySliceToInt(toBitArray([0xb6, 0xe3]), 0, 12, true, false), 0xb6e, ); assertEqual( - toBitArray([0xff, 0xb6, 0xe3]).sliceToInt(20, 24, true, false), + bitArraySliceToInt(toBitArray([0xb6, 0xe3]), 0, 12, false, false), + 0xeb6, +); +assertEqual( + bitArraySliceToInt(toBitArray([0xff, 0xb6, 0xe3]), 8, 20, true, false), + 0xb6e, +); +assertEqual( + bitArraySliceToInt(toBitArray([0xff, 0xb6, 0xe3]), 20, 24, true, false), 0x03, ); assertEqual( - toBitArray([0xff, 0xb6, 0xe3]).sliceToInt(8, 20, false, false), + bitArraySliceToInt(toBitArray([0xff, 0xb6, 0xe3]), 8, 20, false, false), 0xeb6, ); assertEqual( - toBitArray([0xa5, 0x6c, 0xaa]).sliceToInt(5, 18, true, false), + bitArraySliceToInt(toBitArray([0xa5, 0x6c, 0xaa]), 5, 18, true, false), 5554, ); assertEqual( - toBitArray([0xa5, 0x6c, 0xaa]).sliceToInt(5, 18, false, true), + bitArraySliceToInt(toBitArray([0xa5, 0x6c, 0xaa]), 5, 18, false, true), -3411, ); -assertEqual(toBitArray([1, 2, 3]).sliceToInt(0, 8, true, false), 1); -assertEqual(toBitArray([160, 2, 3]).sliceToInt(0, 8, false, true), -96); -assertEqual(toBitArray([1, 2, 3]).sliceToInt(0, 16, true, false), 258); -assertEqual(toBitArray([1, 2, 3]).sliceToInt(0, 16, false, false), 513); -assertEqual(toBitArray([1, 160, 3]).sliceToInt(0, 16, false, true), -24575); -assertEqual(toBitArray([160, 2, 3]).sliceToInt(0, 16, true, false), 40962); -assertEqual(toBitArray([3, 160, 2]).sliceToInt(8, 24, true, true), -24574); +assertEqual(bitArraySliceToInt(toBitArray([1, 2, 3]), 0, 8, true, false), 1); +assertEqual( + bitArraySliceToInt(toBitArray([160, 2, 3]), 0, 8, false, true), + -96, +); +assertEqual(bitArraySliceToInt(toBitArray([1, 2, 3]), 0, 16, true, false), 258); +assertEqual( + bitArraySliceToInt(toBitArray([1, 2, 3]), 0, 16, false, false), + 513, +); +assertEqual( + bitArraySliceToInt(toBitArray([1, 160, 3]), 0, 16, false, true), + -24575, +); +assertEqual( + bitArraySliceToInt(toBitArray([160, 2, 3]), 0, 16, true, false), + 40962, +); +assertEqual( + bitArraySliceToInt(toBitArray([3, 160, 2]), 8, 24, true, true), + -24574, +); assertEqual( - new BitArray(new Uint8Array([146, 192, 70, 25, 128]), 33).sliceToInt( + bitArraySliceToInt( + new BitArray(new Uint8Array([146, 192, 70, 25, 128]), 33), 1, 24, true, @@ -809,11 +869,12 @@ assertEqual( 1_228_870, ); assertEqual( - toBitArray([255, 255, 255, 255]).sliceToInt(0, 32, false, true), + bitArraySliceToInt(toBitArray([255, 255, 255, 255]), 0, 32, false, true), -1, ); assertEqual( - new BitArray(new Uint8Array([217, 150, 209, 191, 0]), 33).sliceToInt( + bitArraySliceToInt( + new BitArray(new Uint8Array([217, 150, 209, 191, 0]), 33), 1, 33, true, @@ -822,7 +883,8 @@ assertEqual( 3_006_112_638, ); assertEqual( - new BitArray(new Uint8Array([146, 192, 70, 25, 128]), 33).sliceToInt( + bitArraySliceToInt( + new BitArray(new Uint8Array([146, 192, 70, 25, 128]), 33), 1, 33, true, @@ -831,7 +893,8 @@ assertEqual( 629_181_491, ); assertEqual( - new BitArray(new Uint8Array([251, 24, 47, 227, 128]), 33).sliceToInt( + bitArraySliceToInt( + new BitArray(new Uint8Array([251, 24, 47, 227, 128]), 33), 1, 33, false, @@ -840,7 +903,8 @@ assertEqual( 3_344_904_438, ); assertEqual( - new BitArray(new Uint8Array([240, 102, 91, 101, 128]), 33).sliceToInt( + bitArraySliceToInt( + new BitArray(new Uint8Array([240, 102, 91, 101, 128]), 33), 0, 33, false, @@ -849,15 +913,28 @@ assertEqual( 5_995_456_240, ); assertEqual( - toBitArray([231, 255, 255, 255, 254, 123]).sliceToInt(0, 40, true, true), + bitArraySliceToInt( + toBitArray([231, 255, 255, 255, 254, 123]), + 0, + 40, + true, + true, + ), -103_079_215_106, ); assertEqual( - toBitArray([0, 231, 255, 255, 253, 123, 17]).sliceToInt(1, 55, true, false), + bitArraySliceToInt( + toBitArray([0, 231, 255, 255, 253, 123, 17]), + 1, + 55, + true, + false, + ), 127_543_348_739_464, ); assertEqual( - toBitArray([142, 231, 255, 255, 253, 123, 17, 139]).sliceToInt( + bitArraySliceToInt( + toBitArray([142, 231, 255, 255, 253, 123, 17, 139]), 8, 62, false, @@ -866,7 +943,8 @@ assertEqual( -8425025061257241, ); assertEqual( - toBitArray([142, 231, 255, 255, 253, 123, 17, 139]).sliceToInt( + bitArraySliceToInt( + toBitArray([142, 231, 255, 255, 253, 123, 17, 139]), 7, 62, false, @@ -875,15 +953,28 @@ assertEqual( -8293899692933261, ); assertEqual( - toBitArray([142, 231, 255, 255, 253, 123, 17]).sliceToInt(8, 48, true, true), + bitArraySliceToInt( + toBitArray([142, 231, 255, 255, 253, 123, 17]), + 8, + 48, + true, + true, + ), -103_079_215_749, ); assertEqual( - toBitArray([255, 255, 255, 255, 255, 255, 255]).sliceToInt(0, 56, true, true), + bitArraySliceToInt( + toBitArray([255, 255, 255, 255, 255, 255, 255]), + 0, + 56, + true, + true, + ), -1, ); assertEqual( - toBitArray([0x00, 0xaa, 255, 255, 255, 255, 255]).sliceToInt( + bitArraySliceToInt( + toBitArray([0x00, 0xaa, 255, 255, 255, 255, 255]), 0, 56, true, @@ -892,7 +983,8 @@ assertEqual( 0xaaffffffffff, ); assertEqual( - toBitArray([255, 255, 255, 255, 255, 0xaa, 0x00]).sliceToInt( + bitArraySliceToInt( + toBitArray([255, 255, 255, 255, 255, 0xaa, 0x00]), 0, 56, false, @@ -901,7 +993,8 @@ assertEqual( 0xaaffffffffff, ); assertEqual( - toBitArray([255, 255, 255, 255, 255, 255, 255]).sliceToInt( + bitArraySliceToInt( + toBitArray([255, 255, 255, 255, 255, 255, 255]), 0, 56, true, @@ -909,16 +1002,26 @@ assertEqual( ), Number(0xfffffffffffffen), ); -assertEqual(toBitArray([0xfe, 0x3f]).sliceToInt(4, 12, true, false), 0xe3); -assertEqual(toBitArray([253, 94]).sliceToInt(3, 11, true, true), -22); -assertEqual(toBitArray([233, 164]).sliceToInt(3, 15, true, false), 1234); -assertEqual(toBitArray([250, 72]).sliceToInt(3, 15, false, false), 1234); assertEqual( - toBitArray([250, 72, 223, 189]).sliceToInt(7, 29, true, false), + bitArraySliceToInt(toBitArray([0xfe, 0x3f]), 4, 12, true, false), + 0xe3, +); +assertEqual(bitArraySliceToInt(toBitArray([253, 94]), 3, 11, true, true), -22); +assertEqual( + bitArraySliceToInt(toBitArray([233, 164]), 3, 15, true, false), + 1234, +); +assertEqual( + bitArraySliceToInt(toBitArray([250, 72]), 3, 15, false, false), + 1234, +); +assertEqual( + bitArraySliceToInt(toBitArray([250, 72, 223, 189]), 7, 29, true, false), 596983, ); assertEqual( - toBitArray([250, 72, 223, 189, 41, 97, 165, 0, 0, 0, 0, 177]).sliceToInt( + bitArraySliceToInt( + toBitArray([250, 72, 223, 189, 41, 97, 165, 0, 0, 0, 0, 177]), 14, 85, false, @@ -927,7 +1030,8 @@ assertEqual( 70821197049655, ); assertEqual( - toBitArray([250, 72, 223, 189, 41, 97, 165, 0, 0, 0, 0, 177]).sliceToInt( + bitArraySliceToInt( + toBitArray([250, 72, 223, 189, 41, 97, 165, 0, 0, 0, 0, 177]), 14, 85, true,