boa_string/

lib.rs

//! A Latin1 or UTF-16 encoded, reference counted, immutable string.// Required per unsafe code standards to ensure every unsafe usage is properly documented.// - `unsafe_op_in_unsafe_fn` will be warn-by-default in edition 2024://   https://github.com/rust-lang/rust/issues/71668#issuecomment-1189396860// - `undocumented_unsafe_blocks` and `missing_safety_doc` requires a `Safety:` section in the//   comment or doc of the unsafe block or function, respectively.#![deny(    unsafe_op_in_unsafe_fn,    clippy::undocumented_unsafe_blocks,    clippy::missing_safety_doc)]#![allow(clippy::module_name_repetitions)]modbuilder;modcommon;moddisplay;moditer;modstr;#[cfg(test)]modtests;useself::{iter::Windows, str::JsSliceIndex};usecrate::display::{JsStrDisplayEscaped, JsStrDisplayLossy};#[doc(inline)]pub use crate::{    builder::{CommonJsStringBuilder, Latin1JsStringBuilder, Utf16JsStringBuilder},    common::StaticJsStrings,    iter::Iter,    str::{JsStr, JsStrVariant},};usestd::fmt::Write;usestd::{    alloc::{Layout, alloc, dealloc},    cell::Cell,    convert::Infallible,    hash::{Hash, Hasher},    process::abort,    ptr::{self, NonNull},    str::FromStr,};usestd::{borrow::Cow, mem::ManuallyDrop};fnalloc_overflow() -> ! {panic!("detected overflow during string allocation")}/// Helper function to check if a `char` is trimmable.pub(crate)const fnis_trimmable_whitespace(c: char) -> bool {// The rust implementation of `trim` does not regard the same characters whitespace as ecma standard does    //    // Rust uses \p{White_Space} by default, which also includes:    // `\u{0085}' (next line)    // And does not include:    // '\u{FEFF}' (zero width non-breaking space)    // Explicit whitespace: https://tc39.es/ecma262/#sec-white-spacematches!(        c,'\u{0009}'|'\u{000B}'|'\u{000C}'|'\u{0020}'|'\u{00A0}'|'\u{FEFF}'|// Unicode Space_Separator category'\u{1680}'|'\u{2000}'..='\u{200A}'|'\u{202F}'|'\u{205F}'|'\u{3000}'|// Line terminators: https://tc39.es/ecma262/#sec-line-terminators'\u{000A}'|'\u{000D}'|'\u{2028}'|'\u{2029}')}/// Helper function to check if a `u8` latin1 character is trimmable.pub(crate)const fnis_trimmable_whitespace_latin1(c: u8) -> bool {// The rust implementation of `trim` does not regard the same characters whitespace as ecma standard does    //    // Rust uses \p{White_Space} by default, which also includes:    // `\u{0085}' (next line)    // And does not include:    // '\u{FEFF}' (zero width non-breaking space)    // Explicit whitespace: https://tc39.es/ecma262/#sec-white-spacematches!(        c,0x09|0x0B|0x0C|0x20|0xA0|// Line terminators: https://tc39.es/ecma262/#sec-line-terminators0x0A|0x0D)}/// Represents a Unicode codepoint within a [`JsString`], which could be a valid/// '[Unicode scalar value]', or an unpaired surrogate.////// [Unicode scalar value]: https://www.unicode.org/glossary/#unicode_scalar_value#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub enumCodePoint {/// A valid Unicode scalar value.Unicode(char),/// An unpaired surrogate.UnpairedSurrogate(u16),}implCodePoint {/// Get the number of UTF-16 code units needed to encode this code point.#[inline]    #[must_use]pub const fncode_unit_count(self) -> usize {matchself{Self::Unicode(c) => c.len_utf16(),Self::UnpairedSurrogate(_) =>1,        }    }/// Convert the code point to its [`u32`] representation.#[inline]    #[must_use]pub fnas_u32(self) -> u32 {matchself{Self::Unicode(c) => u32::from(c),Self::UnpairedSurrogate(surr) => u32::from(surr),        }    }/// If the code point represents a valid 'Unicode scalar value', returns its [`char`]    /// representation, otherwise returns [`None`] on unpaired surrogates.#[inline]    #[must_use]pub const fnas_char(self) ->Option<char> {matchself{Self::Unicode(c) =>Some(c),Self::UnpairedSurrogate(_) =>None,        }    }/// Encodes this code point as UTF-16 into the provided u16 buffer, and then returns the subslice    /// of the buffer that contains the encoded character.    ///    /// # Panics    ///    /// Panics if the buffer is not large enough. A buffer of length 2 is large enough to encode any    /// code point.#[inline]    #[must_use]pub fnencode_utf16(self, dst:&mut[u16]) ->&mut[u16] {matchself{Self::Unicode(c) => c.encode_utf16(dst),Self::UnpairedSurrogate(surr) => {                dst[0] = surr;&mutdst[0..=0]            }        }    }}implstd::fmt::DisplayforCodePoint {#[inline]fnfmt(&self, f:&mutstd::fmt::Formatter<'_>) -> std::fmt::Result {matchself{            CodePoint::Unicode(c) => f.write_char(*c),            CodePoint::UnpairedSurrogate(c) => {write!(f,"\\u{c:04X}")            }        }    }}/// A `usize` contains a flag and the length of Latin1/UTF-16 ./// ```text/// ┌────────────────────────────────────┐/// │ length (usize::BITS - 1) │ flag(1) │/// └────────────────────────────────────┘/// ```/// The latin1/UTF-16 flag is stored in the bottom bit.#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]#[repr(transparent)]structTaggedLen(usize);implTaggedLen {constLATIN1_BITFLAG: usize =1<<0;constBITFLAG_COUNT: usize =1;const fnnew(len: usize, latin1: bool) ->Self{Self((len <<Self::BITFLAG_COUNT) | (latin1asusize))    }const fnis_latin1(self) -> bool {        (self.0&Self::LATIN1_BITFLAG) !=0}const fnlen(self) -> usize {self.0>>Self::BITFLAG_COUNT    }}/// The raw representation of a [`JsString`] in the heap.#[repr(C)]#[allow(missing_debug_implementations)]pub structRawJsString {    tagged_len: TaggedLen,    refcount: Cell<usize>,    data: [u8;0],}implRawJsString {const fnis_latin1(&self) -> bool {self.tagged_len.is_latin1()    }const fnlen(&self) -> usize {self.tagged_len.len()    }}constDATA_OFFSET: usize = size_of::<RawJsString>();enumUnwrapped<'a> {    Heap(NonNull<RawJsString>),    Static(&'aJsStr<'static>),}/// A Latin1 or UTF-16–encoded, reference counted, immutable string.////// This is pretty similar to a <code>[Rc][std::rc::Rc]\<[\[u16\]][slice]\></code>, but without the/// length metadata associated with the `Rc` fat pointer. Instead, the length of every string is/// stored on the heap, along with its reference counter and its data.////// The string can be latin1 (stored as a byte for space efficiency) or U16 encoding.////// We define some commonly used string constants in an interner. For these strings, we don't allocate/// memory on the heap to reduce the overhead of memory allocation and reference counting.#[allow(clippy::module_name_repetitions)]pub structJsString {    ptr: NonNull<RawJsString>,}// JsString should always be pointer sized.static_assertions::assert_eq_size!(JsString,*const());impl<'a> From<&'aJsString>forJsStr<'a> {#[inline]fnfrom(value:&'aJsString) ->Self{        value.as_str()    }}impl<'a> IntoIteratorfor&'aJsString {typeIntoIter = Iter<'a>;typeItem = u16;#[inline]fninto_iter(self) ->Self::IntoIter {self.iter()    }}implJsString {/// Create an iterator over the [`JsString`].#[inline]    #[must_use]pub fniter(&self) -> Iter<'_> {self.as_str().iter()    }/// Create an iterator over overlapping subslices of length size.#[inline]    #[must_use]pub fnwindows(&self, size: usize) -> Windows<'_> {self.as_str().windows(size)    }/// Decodes a [`JsString`] into a [`String`], replacing invalid data with its escaped representation    /// in 4 digit hexadecimal.#[inline]    #[must_use]pub fnto_std_string_escaped(&self) -> String {self.display_escaped().to_string()    }/// Decodes a [`JsString`] into a [`String`], replacing invalid data with the    /// replacement character U+FFFD.#[inline]    #[must_use]pub fnto_std_string_lossy(&self) -> String {self.display_lossy().to_string()    }/// Decodes a [`JsString`] into a [`String`], returning an error if the string contains unpaired    /// surrogates.    ///    /// # Errors    ///    /// [`FromUtf16Error`][std::string::FromUtf16Error] if it contains any invalid data.#[inline]pub fnto_std_string(&self) ->Result<String, std::string::FromUtf16Error> {self.as_str().to_std_string()    }/// Decodes a [`JsString`] into an iterator of [`Result<String, u16>`], returning surrogates as    /// errors.#[inline]pub fnto_std_string_with_surrogates(&self) ->implIterator<Item =Result<String, u16>> +'_{self.as_str().to_std_string_with_surrogates()    }/// Maps the valid segments of an UTF16 string and leaves the unpaired surrogates unchanged.#[inline]    #[must_use]pub fnmap_valid_segments<F>(&self,mutf: F) ->SelfwhereF: FnMut(String) -> String,    {letmuttext = Vec::new();forpartinself.to_std_string_with_surrogates() {matchpart {Ok(string) => text.extend(f(string).encode_utf16()),Err(surr) => text.push(surr),            }        }Self::from(&text[..])    }/// Gets an iterator of all the Unicode codepoints of a [`JsString`].#[inline]pub fncode_points(&self) ->implIterator<Item = CodePoint> + Clone +'_{self.as_str().code_points()    }/// Abstract operation `StringIndexOf ( string, searchValue, fromIndex )`    ///    /// Note: Instead of returning an isize with `-1` as the "not found" value, we make use of the    /// type system and return <code>[Option]\<usize\></code> with [`None`] as the "not found" value.    ///    /// More information:    ///  - [ECMAScript reference][spec]    ///    /// [spec]: https://tc39.es/ecma262/#sec-stringindexof#[inline]    #[must_use]pub fnindex_of(&self, search_value: JsStr<'_>, from_index: usize) ->Option<usize> {self.as_str().index_of(search_value, from_index)    }/// Abstract operation `CodePointAt( string, position )`.    ///    /// The abstract operation `CodePointAt` takes arguments `string` (a String) and `position` (a    /// non-negative integer) and returns a Record with fields `[[CodePoint]]` (a code point),    /// `[[CodeUnitCount]]` (a positive integer), and `[[IsUnpairedSurrogate]]` (a Boolean). It    /// interprets string as a sequence of UTF-16 encoded code points, as described in 6.1.4, and reads    /// from it a single code point starting with the code unit at index `position`.    ///    /// More information:    ///  - [ECMAScript reference][spec]    ///    /// [spec]: https://tc39.es/ecma262/#sec-codepointat    ///    /// # Panics    ///    /// If `position` is smaller than size of string.#[inline]    #[must_use]pub fncode_point_at(&self, position: usize) -> CodePoint {self.as_str().code_point_at(position)    }/// Abstract operation `StringToNumber ( str )`    ///    /// More information:    /// - [ECMAScript reference][spec]    ///    /// [spec]: https://tc39.es/ecma262/#sec-stringtonumber#[inline]    #[must_use]pub fnto_number(&self) -> f64 {self.as_str().to_number()    }/// Get the length of the [`JsString`].#[inline]    #[must_use]pub fnlen(&self) -> usize {self.as_str().len()    }/// Return true if the [`JsString`] is emtpy.#[inline]    #[must_use]pub fnis_empty(&self) -> bool {self.len() ==0}/// Convert the [`JsString`] into a [`Vec<U16>`].#[inline]    #[must_use]pub fnto_vec(&self) -> Vec<u16> {self.as_str().to_vec()    }/// Check if the [`JsString`] contains a byte.#[inline]    #[must_use]pub fncontains(&self, element: u8) -> bool {self.as_str().contains(element)    }/// Trim whitespace from the start and end of the [`JsString`].#[inline]    #[must_use]pub fntrim(&self) -> JsStr<'_> {self.as_str().trim()    }/// Trim whitespace from the start of the [`JsString`].#[inline]    #[must_use]pub fntrim_start(&self) -> JsStr<'_> {self.as_str().trim_start()    }/// Trim whitespace from the end of the [`JsString`].#[inline]    #[must_use]pub fntrim_end(&self) -> JsStr<'_> {self.as_str().trim_end()    }/// Get the element a the given index, [`None`] otherwise.#[inline]    #[must_use]pub fnget<'a, I>(&'aself, index: I) ->Option<I::Value>whereI: JsSliceIndex<'a>,    {self.as_str().get(index)    }/// Returns an element or subslice depending on the type of index, without doing bounds check.    ///    /// # Safety    ///    /// Caller must ensure the index is not out of bounds#[inline]    #[must_use]pub unsafe fnget_unchecked<'a, I>(&'aself, index: I) -> I::ValuewhereI: JsSliceIndex<'a>,    {// SAFETY: Caller must ensure the index is not out of boundsunsafe{self.as_str().get_unchecked(index) }    }/// Get the element a the given index.    ///    /// # Panics    ///    /// If the index is out of bounds.#[inline]    #[must_use]pub fnget_expect<'a, I>(&'aself, index: I) -> I::ValuewhereI: JsSliceIndex<'a>,    {self.as_str().get_expect(index)    }/// Gets a displayable escaped string. This may be faster and has fewer    /// allocations than `format!("{}", str.to_string_escaped())` when    /// displaying.#[inline]    #[must_use]pub fndisplay_escaped(&self) -> JsStrDisplayEscaped<'_> {self.as_str().display_escaped()    }/// Gets a displayable lossy string. This may be faster and has fewer    /// allocations than `format!("{}", str.to_string_lossy())` when displaying.#[inline]    #[must_use]pub fndisplay_lossy(&self) -> JsStrDisplayLossy<'_> {self.as_str().display_lossy()    }/// Consumes the [`JsString`], returning a pointer to `RawJsString`.    ///    /// To avoid a memory leak the pointer must be converted back to a `JsString` using    /// [`JsString::from_raw`].#[inline]    #[must_use]pub fninto_raw(self) -> NonNull<RawJsString> {        ManuallyDrop::new(self).ptr    }/// Constructs a `JsString` from a pointer to `RawJsString`.    ///    /// The raw pointer must have been previously returned by a call to    /// [`JsString::into_raw`].    ///    /// # Safety    ///    /// This function is unsafe because improper use may lead to memory unsafety,    /// even if the returned `JsString` is never accessed.#[inline]    #[must_use]pub unsafe fnfrom_raw(ptr: NonNull<RawJsString>) ->Self{Self{ ptr }    }}// `&JsStr<'static>` must always be aligned so it can be taggged.static_assertions::const_assert!(align_of::<*constJsStr<'static>>() >=2);implJsString {/// Create a [`JsString`] from a static js string.#[must_use]pub const fnfrom_static_js_str(src:&'staticJsStr<'static>) ->Self{letsrc = ptr::from_ref(src);// SAFETY: A reference cannot be null, so this is safe.        //        // TODO: Replace once `NonNull::from_ref()` is stabilized.letptr =unsafe{ NonNull::new_unchecked(src.cast_mut()) };// SAFETY:        // - Adding one to an aligned pointer will tag the pointer's last bit.        // - The pointer's provenance remains unchanged, so this is safe.lettagged_ptr =unsafe{ ptr.byte_add(1) };        JsString {            ptr: tagged_ptr.cast::<RawJsString>(),        }    }/// Check if the [`JsString`] is static.#[inline]    #[must_use]pub fnis_static(&self) -> bool {self.ptr.addr().get() &1!=0}pub(crate)fnunwrap(&self) -> Unwrapped<'_> {ifself.is_static() {// SAFETY: Static pointer is tagged and already checked, so this is safe.letptr =unsafe{self.ptr.byte_sub(1) };// SAFETY: A static pointer always points to a valid JsStr, so this is safe.Unwrapped::Static(unsafe{ ptr.cast::<JsStr<'static>>().as_ref() })        }else{            Unwrapped::Heap(self.ptr)        }    }/// Obtains the underlying [`&[u16]`][slice] slice of a [`JsString`]#[inline]    #[must_use]pub fnas_str(&self) -> JsStr<'_> {letptr =matchself.unwrap() {            Unwrapped::Heap(ptr) => ptr.as_ptr(),            Unwrapped::Static(js_str) =>return*js_str,        };// SAFETY:        // - Unwrapped heap ptr is always a valid heap allocated RawJsString.        // - Length of a heap allocated string always contains the correct size of the string.unsafe{lettagged_len = (*ptr).tagged_len;letlen = tagged_len.len();letis_latin1 = tagged_len.is_latin1();letptr = (&rawconst(*ptr).data).cast::<u8>();ifis_latin1 {                JsStr::latin1(std::slice::from_raw_parts(ptr, len))            }else{// SAFETY: Raw data string is always correctly aligned when allocated.#[allow(clippy::cast_ptr_alignment)]JsStr::utf16(std::slice::from_raw_parts(ptr.cast::<u16>(), len))            }        }    }/// Creates a new [`JsString`] from the concatenation of `x` and `y`.#[inline]    #[must_use]pub fnconcat(x: JsStr<'_>, y: JsStr<'_>) ->Self{Self::concat_array(&[x, y])    }/// Creates a new [`JsString`] from the concatenation of every element of    /// `strings`.#[inline]    #[must_use]pub fnconcat_array(strings:&[JsStr<'_>]) ->Self{letmutlatin1_encoding =true;letmutfull_count =0usize;forstringinstrings {letSome(sum) = full_count.checked_add(string.len())else{                alloc_overflow()            };if!string.is_latin1() {                latin1_encoding =false;            }            full_count = sum;        }letptr =Self::allocate_inner(full_count, latin1_encoding);letstring = {// SAFETY: `allocate_inner` guarantees that `ptr` is a valid pointer.letmutdata =unsafe{ (&rawmut(*ptr.as_ptr()).data).cast::<u8>() };for&stringinstrings {// SAFETY:                // The sum of all `count` for each `string` equals `full_count`, and since we're                // iteratively writing each of them to `data`, `copy_non_overlapping` always stays                // in-bounds for `count` reads of each string and `full_count` writes to `data`.                //                // Each `string` must be properly aligned to be a valid slice, and `data` must be                // properly aligned by `allocate_inner`.                //                // `allocate_inner` must return a valid pointer to newly allocated memory, meaning                // `ptr` and all `string`s should never overlap.unsafe{// NOTE: The aligment is checked when we allocate the array.#[allow(clippy::cast_ptr_alignment)]match(latin1_encoding, string.variant()) {                        (true, JsStrVariant::Latin1(s)) => {letcount = s.len();                            ptr::copy_nonoverlapping(s.as_ptr(), data.cast::<u8>(), count);                            data = data.cast::<u8>().add(count).cast::<u8>();                        }                        (false, JsStrVariant::Latin1(s)) => {letcount = s.len();for(i, byte)ins.iter().enumerate() {*data.cast::<u16>().add(i) = u16::from(*byte);                            }                            data = data.cast::<u16>().add(count).cast::<u8>();                        }                        (false, JsStrVariant::Utf16(s)) => {letcount = s.len();                            ptr::copy_nonoverlapping(s.as_ptr(), data.cast::<u16>(), count);                            data = data.cast::<u16>().add(count).cast::<u8>();                        }                        (true, JsStrVariant::Utf16(_)) => {unreachable!("Already checked that it's latin1 encoding")                        }                    }                }            }Self{// SAFETY: We already know it's a valid heap pointer.ptr:unsafe{ NonNull::new_unchecked(ptr.as_ptr()) },            }        };        StaticJsStrings::get_string(&string.as_str()).unwrap_or(string)    }/// Allocates a new [`RawJsString`] with an internal capacity of `str_len` chars.    ///    /// # Panics    ///    /// Panics if `try_allocate_inner` returns `Err`.fnallocate_inner(str_len: usize, latin1: bool) -> NonNull<RawJsString> {matchSelf::try_allocate_inner(str_len, latin1) {Ok(v) => v,Err(None) => alloc_overflow(),Err(Some(layout)) => std::alloc::handle_alloc_error(layout),        }    }// This is marked as safe because it is always valid to call this function to request any number    // of `u16`, since this function ought to fail on an OOM error./// Allocates a new [`RawJsString`] with an internal capacity of `str_len` chars.    ///    /// # Errors    ///    /// Returns `Err(None)` on integer overflows `usize::MAX`.    /// Returns `Err(Some(Layout))` on allocation error.fntry_allocate_inner(        str_len: usize,        latin1: bool,    ) ->Result<NonNull<RawJsString>,Option<Layout>> {let(layout, offset) =iflatin1 {            Layout::array::<u8>(str_len)        }else{            Layout::array::<u16>(str_len)        }        .and_then(|arr| Layout::new::<RawJsString>().extend(arr))        .map(|(layout, offset)| (layout.pad_to_align(), offset))        .map_err(|_|None)?;debug_assert_eq!(offset, DATA_OFFSET);#[allow(clippy::cast_ptr_alignment)]// SAFETY:        // The layout size of `RawJsString` is never zero, since it has to store        // the length of the string and the reference count.letinner =unsafe{ alloc(layout).cast::<RawJsString>() };// We need to verify that the pointer returned by `alloc` is not null, otherwise        // we should abort, since an allocation error is pretty unrecoverable for us        // right now.letinner = NonNull::new(inner).ok_or(Some(layout))?;// SAFETY:        // `NonNull` verified for us that the pointer returned by `alloc` is valid,        // meaning we can write to its pointed memory.unsafe{// Write the first part, the `RawJsString`.inner.as_ptr().write(RawJsString {                tagged_len: TaggedLen::new(str_len, latin1),                refcount: Cell::new(1),                data: [0;0],            });        }debug_assert!({letinner = inner.as_ptr();// SAFETY:            // - `inner` must be a valid pointer, since it comes from a `NonNull`,            // meaning we can safely dereference it to `RawJsString`.            // - `offset` should point us to the beginning of the array,            // and since we requested an `RawJsString` layout with a trailing            // `[u16; str_len]`, the memory of the array must be in the `usize`            // range for the allocation to succeed.unsafe{                ptr::eq(                    inner.cast::<u8>().add(offset).cast(),                    (*inner).data.as_mut_ptr(),                )            }        });Ok(inner)    }/// Creates a new [`JsString`] from `data`, without checking if the string is in the interner.fnfrom_slice_skip_interning(string: JsStr<'_>) ->Self{letcount = string.len();letptr =Self::allocate_inner(count, string.is_latin1());// SAFETY: `allocate_inner` guarantees that `ptr` is a valid pointer.letdata =unsafe{ (&rawmut(*ptr.as_ptr()).data).cast::<u8>() };// SAFETY:        // - We read `count = data.len()` elements from `data`, which is within the bounds of the slice.        // - `allocate_inner` must allocate at least `count` elements, which allows us to safely        //   write at least `count` elements.        // - `allocate_inner` should already take care of the alignment of `ptr`, and `data` must be        //   aligned to be a valid slice.        // - `allocate_inner` must return a valid pointer to newly allocated memory, meaning `ptr`        //   and `data` should never overlap.unsafe{// NOTE: The aligment is checked when we allocate the array.#[allow(clippy::cast_ptr_alignment)]matchstring.variant() {                JsStrVariant::Latin1(s) => {                    ptr::copy_nonoverlapping(s.as_ptr(), data.cast::<u8>(), count);                }                JsStrVariant::Utf16(s) => {                    ptr::copy_nonoverlapping(s.as_ptr(), data.cast::<u16>(), count);                }            }        }Self{ ptr }    }/// Creates a new [`JsString`] from `data`.fnfrom_slice(string: JsStr<'_>) ->Self{if letSome(s) = StaticJsStrings::get_string(&string) {returns;        }Self::from_slice_skip_interning(string)    }/// Gets the number of `JsString`s which point to this allocation.#[inline]    #[must_use]pub fnrefcount(&self) ->Option<usize> {ifself.is_static() {returnNone;        }// SAFETY:        // `NonNull` and the constructions of `JsString` guarantee that `inner` is always valid.letrc =unsafe{self.ptr.as_ref().refcount.get() };Some(rc)    }}implCloneforJsString {#[inline]fnclone(&self) ->Self{ifself.is_static() {returnSelf{ ptr:self.ptr };        }// SAFETY: `NonNull` and the constructions of `JsString` guarantee that `inner` is always valid.letinner =unsafe{self.ptr.as_ref() };letstrong = inner.refcount.get().wrapping_add(1);ifstrong ==0{            abort()        }        inner.refcount.set(strong);Self{ ptr:self.ptr }    }}implDefaultforJsString {#[inline]fndefault() ->Self{        StaticJsStrings::EMPTY_STRING    }}implDropforJsString {#[inline]fndrop(&mutself) {// See https://doc.rust-lang.org/src/alloc/sync.rs.html#1672 for details.ifself.is_static() {return;        }// SAFETY: `NonNull` and the constructions of `JsString` guarantees that `raw` is always valid.letinner =unsafe{self.ptr.as_ref() };        inner.refcount.set(inner.refcount.get() -1);ifinner.refcount.get() !=0{return;        }// SAFETY:        // All the checks for the validity of the layout have already been made on `alloc_inner`,        // so we can skip the unwrap.letlayout =unsafe{ifinner.is_latin1() {                Layout::for_value(inner)                    .extend(Layout::array::<u8>(inner.len()).unwrap_unchecked())                    .unwrap_unchecked()                    .0.pad_to_align()            }else{                Layout::for_value(inner)                    .extend(Layout::array::<u16>(inner.len()).unwrap_unchecked())                    .unwrap_unchecked()                    .0.pad_to_align()            }        };// SAFETY:        // If refcount is 0 and we call drop, that means this is the last `JsString` which        // points to this memory allocation, so deallocating it is safe.unsafe{            dealloc(self.ptr.cast().as_ptr(), layout);        }    }}implstd::fmt::DebugforJsString {#[inline]fnfmt(&self, f:&mutstd::fmt::Formatter<'_>) -> std::fmt::Result {self.as_str().fmt(f)    }}implEqforJsString {}macro_rules! impl_from_number_for_js_string {    ($($module: ident => $($ty:ty),+)+) => {        $(            $(implFrom<$ty>forJsString {#[inline]fnfrom(value:$ty) ->Self{                        JsString::from_slice_skip_interning(JsStr::latin1($module::Buffer::new().format(value).as_bytes(),                        ))                    }                }            )+        )+    };}impl_from_number_for_js_string!(    itoa => i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize    ryu_js => f32, f64);implFrom<&[u16]>forJsString {#[inline]fnfrom(s:&[u16]) ->Self{        JsString::from_slice(JsStr::utf16(s))    }}implFrom<&str>forJsString {#[inline]fnfrom(s:&str) ->Self{// TODO: Check for latin1 encodingifs.is_ascii() {letjs_str = JsStr::latin1(s.as_bytes());returnStaticJsStrings::get_string(&js_str)                .unwrap_or_else(|| JsString::from_slice_skip_interning(js_str));        }lets = s.encode_utf16().collect::<Vec<_>>();        JsString::from_slice_skip_interning(JsStr::utf16(&s[..]))    }}implFrom<JsStr<'_>>forJsString {#[inline]fnfrom(value: JsStr<'_>) ->Self{        StaticJsStrings::get_string(&value)            .unwrap_or_else(|| JsString::from_slice_skip_interning(value))    }}implFrom<&[JsString]>forJsString {#[inline]fnfrom(value:&[JsString]) ->Self{Self::concat_array(&value.iter().map(Self::as_str).collect::<Vec<_>>()[..])    }}impl<constN: usize> From<&[JsString; N]>forJsString {#[inline]fnfrom(value:&[JsString; N]) ->Self{Self::concat_array(&value.iter().map(Self::as_str).collect::<Vec<_>>()[..])    }}implFrom<String>forJsString {#[inline]fnfrom(s: String) ->Self{Self::from(s.as_str())    }}impl<'a> From<Cow<'a, str>>forJsString {#[inline]fnfrom(s: Cow<'a, str>) ->Self{matchs {            Cow::Borrowed(s) => s.into(),            Cow::Owned(s) => s.into(),        }    }}impl<constN: usize> From<&[u16; N]>forJsString {#[inline]fnfrom(s:&[u16; N]) ->Self{Self::from(&s[..])    }}implHashforJsString {#[inline]fnhash<H: Hasher>(&self, state:&mutH) {self.as_str().hash(state);    }}implPartialOrdforJsStr<'_> {#[inline]fnpartial_cmp(&self, other:&Self) ->Option<std::cmp::Ordering> {Some(self.cmp(other))    }}implOrdforJsString {#[inline]fncmp(&self, other:&Self) -> std::cmp::Ordering {self.as_str().cmp(&other.as_str())    }}implPartialEqforJsString {#[inline]fneq(&self, other:&Self) -> bool {self.as_str() == other.as_str()    }}implPartialEq<JsString>for[u16] {#[inline]fneq(&self, other:&JsString) -> bool {ifself.len() != other.len() {returnfalse;        }for(x, y)inself.iter().copied().zip(other.iter()) {ifx != y {returnfalse;            }        }true}}impl<constN: usize> PartialEq<JsString>for[u16; N] {#[inline]fneq(&self, other:&JsString) -> bool {self[..] ==*other    }}implPartialEq<[u16]>forJsString {#[inline]fneq(&self, other:&[u16]) -> bool {        other ==self}}impl<constN: usize> PartialEq<[u16; N]>forJsString {#[inline]fneq(&self, other:&[u16; N]) -> bool {*self== other[..]    }}implPartialEq<str>forJsString {#[inline]fneq(&self, other:&str) -> bool {self.as_str() == other    }}implPartialEq<&str>forJsString {#[inline]fneq(&self, other: &&str) -> bool {self.as_str() ==*other    }}implPartialEq<JsString>forstr {#[inline]fneq(&self, other:&JsString) -> bool {        other ==self}}implPartialEq<JsStr<'_>>forJsString {#[inline]fneq(&self, other:&JsStr<'_>) -> bool {self.as_str() ==*other    }}implPartialEq<JsString>forJsStr<'_> {#[inline]fneq(&self, other:&JsString) -> bool {        other ==self}}implPartialOrdforJsString {#[inline]fnpartial_cmp(&self, other:&Self) ->Option<std::cmp::Ordering> {Some(self.cmp(other))    }}implFromStrforJsString {typeErr= Infallible;#[inline]fnfrom_str(s:&str) ->Result<Self,Self::Err> {Ok(Self::from(s))    }}