nodejs
diff --git a/‎deps/icu-small/LICENSE‎
Lines changed: 26 additions & 0 deletions b/‎deps/icu-small/LICENSE‎
Lines changed: 26 additions & 0 deletions
diff --git a/‎deps/icu-small/README-FULL-ICU.txt‎
Lines changed: 2 additions & 2 deletions b/‎deps/icu-small/README-FULL-ICU.txt‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎deps/icu-small/source/common/BUILD.bazel‎
Lines changed: 1 addition & 0 deletions b/‎deps/icu-small/source/common/BUILD.bazel‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎deps/icu-small/source/common/brkiter.cpp‎
Lines changed: 18 additions & 29 deletions b/‎deps/icu-small/source/common/brkiter.cpp‎
Lines changed: 18 additions & 29 deletions
diff --git a/‎deps/icu-small/source/common/charstr.h‎
Lines changed: 41 additions & 45 deletions b/‎deps/icu-small/source/common/charstr.h‎
Lines changed: 41 additions & 45 deletions
diff --git a/‎deps/icu-small/source/common/cmemory.h‎
Lines changed: 0 additions & 4 deletions b/‎deps/icu-small/source/common/cmemory.h‎
Lines changed: 0 additions & 4 deletions
diff --git a/‎deps/icu-small/source/common/cstr.h‎
Lines changed: 4 additions & 4 deletions b/‎deps/icu-small/source/common/cstr.h‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎deps/icu-small/source/common/fixedstring.cpp‎
Lines changed: 29 additions & 0 deletions b/‎deps/icu-small/source/common/fixedstring.cpp‎
Lines changed: 29 additions & 0 deletions
@@ -540,3 +540,29 @@ publicity pertaining to distribution of the software without specific,
 written prior permission.  M.I.T. makes no representations about the
 suitability of this software for any purpose.  It is provided "as is"
 without express or implied warranty.
+
+----------------------------------------------------------------------
+
+File: sorttable.js (only for ICU4J)
+
+The MIT Licence, for code from kryogenix.org
+
+Code downloaded from the Browser Experiments section of kryogenix.org is
+licenced under the so-called MIT licence. The licence is below.
+
+Copyright (c) 1997-date Stuart Langridge
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -1,8 +1,8 @@
 ICU sources - auto generated by shrink-icu-src.py
 
 This directory contains the ICU subset used by --with-intl=full-icu
-It is a strict subset of ICU 77 source files with the following exception(s):
-* deps/icu-small/source/data/in/icudt77l.dat.bz2 : compressed data file
+It is a strict subset of ICU 78 source files with the following exception(s):
+* deps/icu-small/source/data/in/icudt78l.dat.bz2 : compressed data file
 
 
 To rebuild this directory, see ../../tools/icu/README.md
 
@@ -64,6 +64,7 @@ cc_library(
         "umutex.cpp",
         "sharedobject.cpp",
         "utrace.cpp",
+        "fixedstring.cpp",
     ],
     deps = [
         ":headers",
 
@@ -121,11 +121,9 @@ BreakIterator::buildInstance(const Locale& loc, const char *type, UErrorCode &st
 
     // If there is a result, set the valid locale and actual locale, and the kind
     if (U_SUCCESS(status) && result != nullptr) {
-        U_LOCALE_BASED(locBased, *(BreakIterator*)result);
-
-        locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status),
-                              actual.data(), status);
-        LocaleBased::setLocaleID(loc.getName(), result->requestLocale, status);
+        result->actualLocale = Locale(actual.data());
+        result->validLocale = Locale(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status));
+        result->requestLocale = loc;
     }
 
     ures_close(b);
@@ -204,33 +202,28 @@ BreakIterator::getAvailableLocales(int32_t& count)
 //-------------------------------------------
 
 BreakIterator::BreakIterator()
+    : actualLocale(Locale::getRoot()), validLocale(Locale::getRoot()), requestLocale(Locale::getRoot())
 {
 }
 
-BreakIterator::BreakIterator(const BreakIterator &other) : UObject(other) {
-    UErrorCode status = U_ZERO_ERROR;
-    U_LOCALE_BASED(locBased, *this);
-    locBased.setLocaleIDs(other.validLocale, other.actualLocale, status);
-    LocaleBased::setLocaleID(other.requestLocale, requestLocale, status);
-    U_ASSERT(U_SUCCESS(status));
+BreakIterator::BreakIterator(const BreakIterator &other)
+    : UObject(other),
+      actualLocale(other.actualLocale),
+      validLocale(other.validLocale),
+      requestLocale(other.requestLocale) {
 }
 
 BreakIterator &BreakIterator::operator =(const BreakIterator &other) {
     if (this != &other) {
-        UErrorCode status = U_ZERO_ERROR;
-        U_LOCALE_BASED(locBased, *this);
-        locBased.setLocaleIDs(other.validLocale, other.actualLocale, status);
-        LocaleBased::setLocaleID(other.requestLocale, requestLocale, status);
-        U_ASSERT(U_SUCCESS(status));
+        actualLocale = other.actualLocale;
+        validLocale = other.validLocale;
+        requestLocale = other.requestLocale;
     }
     return *this;
 }
 
 BreakIterator::~BreakIterator()
 {
-    delete validLocale;
-    delete actualLocale;
-    delete requestLocale;
 }
 
 // ------------------------------------------
@@ -398,8 +391,8 @@ BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& statu
         // THIS LONG is a sign of bad code -- so the action item is to
         // revisit this in ICU 3.0 and clean it up/fix it/remove it.
         if (U_SUCCESS(status) && (result != nullptr) && *actualLoc.getName() != 0) {
-            U_LOCALE_BASED(locBased, *result);
-            locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName(), status);
+            result->actualLocale = actualLoc;
+            result->validLocale = actualLoc;
         }
         return result;
     }
@@ -506,8 +499,7 @@ BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
         return Locale::getRoot();
     }
     if (type == ULOC_REQUESTED_LOCALE) {
-        return requestLocale == nullptr ?
-            Locale::getRoot() : Locale(requestLocale->data());
+        return requestLocale;
     }
     return LocaleBased::getLocale(validLocale, actualLocale, type, status);
 }
@@ -518,7 +510,7 @@ BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
         return nullptr;
     }
     if (type == ULOC_REQUESTED_LOCALE) {
-        return requestLocale == nullptr ?  "" : requestLocale->data();
+        return requestLocale.getName();
     }
     return LocaleBased::getLocaleID(validLocale, actualLocale, type, status);
 }
@@ -546,11 +538,8 @@ int32_t BreakIterator::getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UE
     return 1;
 }
 
-BreakIterator::BreakIterator (const Locale& valid, const Locale& actual) {
-  UErrorCode status = U_ZERO_ERROR;
-  U_LOCALE_BASED(locBased, (*this));
-  locBased.setLocaleIDs(valid.getName(), actual.getName(), status);
-  U_ASSERT(U_SUCCESS(status));
+BreakIterator::BreakIterator(const Locale& valid, const Locale& actual)
+    : actualLocale(actual), validLocale(valid), requestLocale(Locale::getRoot()) {
 }
 
 U_NAMESPACE_END
 
@@ -21,12 +21,6 @@
 
 U_NAMESPACE_BEGIN
 
-// Windows needs us to DLL-export the MaybeStackArray template specialization,
-// but MacOS X cannot handle it. Same as in digitlst.h.
-#if !U_PLATFORM_IS_DARWIN_BASED
-template class U_COMMON_API MaybeStackArray<char, 40>;
-#endif
-
 /**
  * ICU-internal char * string class.
  * This class does not assume or enforce any particular character encoding.
@@ -38,56 +32,56 @@ template class U_COMMON_API MaybeStackArray<char, 40>;
  * For example:
  *   cs.data()[5]='a';  // no need for setCharAt(5, 'a')
  */
-class U_COMMON_API CharString : public UMemory {
+class U_COMMON_API_CLASS CharString : public UMemory {
 public:
-    CharString() : len(0) { buffer[0]=0; }
-    CharString(StringPiece s, UErrorCode &errorCode) : len(0) {
+    U_COMMON_API CharString() : len(0) { buffer[0]=0; }
+    U_COMMON_API CharString(StringPiece s, UErrorCode &errorCode) : len(0) {
         buffer[0]=0;
         append(s, errorCode);
     }
-    CharString(const CharString &s, UErrorCode &errorCode) : len(0) {
+    U_COMMON_API CharString(const CharString &s, UErrorCode &errorCode) : len(0) {
         buffer[0]=0;
         append(s, errorCode);
     }
-    CharString(const char *s, int32_t sLength, UErrorCode &errorCode) : len(0) {
+    U_COMMON_API CharString(const char *s, int32_t sLength, UErrorCode &errorCode) : len(0) {
         buffer[0]=0;
         append(s, sLength, errorCode);
     }
-    ~CharString() {}
+    U_COMMON_API ~CharString() {}
 
     /**
      * Move constructor; might leave src in an undefined state.
      * This string will have the same contents and state that the source string had.
      */
-    CharString(CharString &&src) noexcept;
+    U_COMMON_API CharString(CharString &&src) noexcept;
     /**
      * Move assignment operator; might leave src in an undefined state.
      * This string will have the same contents and state that the source string had.
      * The behavior is undefined if *this and src are the same object.
      */
-    CharString &operator=(CharString &&src) noexcept;
+    U_COMMON_API CharString &operator=(CharString &&src) noexcept;
 
     /**
      * Replaces this string's contents with the other string's contents.
      * CharString does not support the standard copy constructor nor
      * the assignment operator, to make copies explicit and to
      * use a UErrorCode where memory allocations might be needed.
      */
-    CharString &copyFrom(const CharString &other, UErrorCode &errorCode);
-    CharString &copyFrom(StringPiece s, UErrorCode &errorCode);
+    U_COMMON_API CharString &copyFrom(const CharString &other, UErrorCode &errorCode);
+    U_COMMON_API CharString &copyFrom(StringPiece s, UErrorCode &errorCode);
 
-    UBool isEmpty() const { return len==0; }
-    int32_t length() const { return len; }
-    char operator[](int32_t index) const { return buffer[index]; }
-    StringPiece toStringPiece() const { return StringPiece(buffer.getAlias(), len); }
+    U_COMMON_API UBool isEmpty() const { return len==0; }
+    U_COMMON_API int32_t length() const { return len; }
+    U_COMMON_API char operator[](int32_t index) const { return buffer[index]; }
+    U_COMMON_API StringPiece toStringPiece() const { return StringPiece(buffer.getAlias(), len); }
 
-    const char *data() const { return buffer.getAlias(); }
-    char *data() { return buffer.getAlias(); }
+    U_COMMON_API const char *data() const { return buffer.getAlias(); }
+    U_COMMON_API char *data() { return buffer.getAlias(); }
     /**
      * Allocates length()+1 chars and copies the NUL-terminated data().
      * The caller must uprv_free() the result.
      */
-    char *cloneData(UErrorCode &errorCode) const;
+    U_COMMON_API char *cloneData(UErrorCode &errorCode) const;
     /**
      * Copies the contents of the string into dest.
      * Checks if there is enough space in dest, extracts the entire string if possible,
@@ -103,40 +97,40 @@ class U_COMMON_API CharString : public UMemory {
      * @param errorCode ICU error code.
      * @return length()
      */
-    int32_t extract(char *dest, int32_t capacity, UErrorCode &errorCode) const;
+    U_COMMON_API int32_t extract(char *dest, int32_t capacity, UErrorCode &errorCode) const;
 
-    bool operator==(const CharString& other) const {
+    U_COMMON_API bool operator==(const CharString& other) const {
         return len == other.length() && (len == 0 || uprv_memcmp(data(), other.data(), len) == 0);
     }
-    bool operator!=(const CharString& other) const {
+    U_COMMON_API bool operator!=(const CharString& other) const {
         return !operator==(other);
     }
 
-    bool operator==(StringPiece other) const {
+    U_COMMON_API bool operator==(StringPiece other) const {
         return len == other.length() && (len == 0 || uprv_memcmp(data(), other.data(), len) == 0);
     }
-    bool operator!=(StringPiece other) const {
+    U_COMMON_API bool operator!=(StringPiece other) const {
         return !operator==(other);
     }
 
     /** @return last index of c, or -1 if c is not in this string */
-    int32_t lastIndexOf(char c) const;
+    U_COMMON_API int32_t lastIndexOf(char c) const;
 
-    bool contains(StringPiece s) const;
+    U_COMMON_API bool contains(StringPiece s) const;
 
-    CharString &clear() { len=0; buffer[0]=0; return *this; }
-    CharString &truncate(int32_t newLength);
+    U_COMMON_API CharString &clear() { len=0; buffer[0]=0; return *this; }
+    U_COMMON_API CharString &truncate(int32_t newLength);
 
-    CharString &append(char c, UErrorCode &errorCode);
-    CharString &append(StringPiece s, UErrorCode &errorCode) {
+    U_COMMON_API CharString &append(char c, UErrorCode &errorCode);
+    U_COMMON_API CharString &append(StringPiece s, UErrorCode &errorCode) {
         return append(s.data(), s.length(), errorCode);
     }
-    CharString &append(const CharString &s, UErrorCode &errorCode) {
+    U_COMMON_API CharString &append(const CharString &s, UErrorCode &errorCode) {
         return append(s.data(), s.length(), errorCode);
     }
-    CharString &append(const char *s, int32_t sLength, UErrorCode &status);
+    U_COMMON_API CharString &append(const char *s, int32_t sLength, UErrorCode &status);
 
-    CharString &appendNumber(int64_t number, UErrorCode &status);
+    U_COMMON_API CharString &appendNumber(int64_t number, UErrorCode &status);
 
     /**
      * Returns a writable buffer for appending and writes the buffer's capacity to
@@ -158,26 +152,28 @@ class U_COMMON_API CharString : public UMemory {
      * @param errorCode in/out error code
      * @return a buffer with resultCapacity>=min_capacity
      */
-    char *getAppendBuffer(int32_t minCapacity,
-                          int32_t desiredCapacityHint,
-                          int32_t &resultCapacity,
-                          UErrorCode &errorCode);
+    U_COMMON_API char *getAppendBuffer(int32_t minCapacity,
+                                       int32_t desiredCapacityHint,
+                                       int32_t &resultCapacity,
+                                       UErrorCode &errorCode);
 
-    CharString &appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode);
-    CharString &appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode& errorCode);
+    U_COMMON_API CharString &appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode);
+    U_COMMON_API CharString &appendInvariantChars(const char16_t* uchars,
+                                                  int32_t ucharsLen,
+                                                  UErrorCode& errorCode);
 
     /**
      * Appends a filename/path part, e.g., a directory name.
      * First appends a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR if necessary.
      * Does nothing if s is empty.
      */
-    CharString &appendPathPart(StringPiece s, UErrorCode &errorCode);
+    U_COMMON_API CharString &appendPathPart(StringPiece s, UErrorCode &errorCode);
 
     /**
      * Appends a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR if this string is not empty
      * and does not already end with a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR.
      */
-    CharString &ensureEndsWithFileSeparator(UErrorCode &errorCode);
+    U_COMMON_API CharString &ensureEndsWithFileSeparator(UErrorCode &errorCode);
 
 private:
     MaybeStackArray<char, 40> buffer;
 
@@ -334,9 +334,7 @@ class MaybeStackArray {
     // No heap allocation. Use only on the stack.
     static void* U_EXPORT2 operator new(size_t) noexcept = delete;
     static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
-#if U_HAVE_PLACEMENT_NEW
     static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;
-#endif
 
     /**
      * Default constructor initializes with internal T[stackCapacity] buffer.
@@ -570,9 +568,7 @@ class MaybeStackHeaderAndArray {
     // No heap allocation. Use only on the stack.
     static void* U_EXPORT2 operator new(size_t) noexcept = delete;
     static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
-#if U_HAVE_PLACEMENT_NEW
     static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;
-#endif
 
     /**
      * Default constructor initializes with internal H+T[stackCapacity] buffer.
 
@@ -43,11 +43,11 @@
 
 U_NAMESPACE_BEGIN
 
-class U_COMMON_API CStr : public UMemory {
+class U_COMMON_API_CLASS CStr : public UMemory {
   public:
-    CStr(const UnicodeString &in);
-    ~CStr();
-    const char * operator ()() const;
+    U_COMMON_API CStr(const UnicodeString &in);
+    U_COMMON_API ~CStr();
+    U_COMMON_API const char * operator ()() const;
 
   private:
     CharString s;
 
@@ -0,0 +1,29 @@
+// © 2025 and later: Unicode, Inc. and others.
+// License & terms of use: https://www.unicode.org/copyright.html
+
+#include "fixedstring.h"
+
+#include "unicode/unistr.h"
+#include "unicode/utypes.h"
+
+U_NAMESPACE_BEGIN
+
+U_EXPORT void copyInvariantChars(const UnicodeString& src, FixedString& dst, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+
+    if (src.isEmpty()) {
+        dst.clear();
+        return;
+    }
+
+    int32_t length = src.length();
+    if (!dst.reserve(length + 1)) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+    src.extract(0, length, dst.getAlias(), length + 1, US_INV);
+}
+
+U_NAMESPACE_END
Original file line number	Diff line number	Diff line change
`@@ -121,11 +121,9 @@ BreakIterator::buildInstance(const Locale& loc, const char *type, UErrorCode &st`
`121`	`121`
`122`	`122`	`// If there is a result, set the valid locale and actual locale, and the kind`
`123`	`123`	`if (U_SUCCESS(status) && result != nullptr) {`
`124`		`- U_LOCALE_BASED(locBased, (BreakIterator)result);`
`125`		`-`
`126`		`- locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status),`
`127`		`- actual.data(), status);`
`128`		`- LocaleBased::setLocaleID(loc.getName(), result->requestLocale, status);`
	`124`	`+ result->actualLocale = Locale(actual.data());`
	`125`	`+ result->validLocale = Locale(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status));`
	`126`	`+ result->requestLocale = loc;`
`129`	`127`	`}`
`130`	`128`
`131`	`129`	`ures_close(b);`
`@@ -204,33 +202,28 @@ BreakIterator::getAvailableLocales(int32_t& count)`
`204`	`202`	`//-------------------------------------------`
`205`	`203`
`206`	`204`	`BreakIterator::BreakIterator()`
	`205`	`+ : actualLocale(Locale::getRoot()), validLocale(Locale::getRoot()), requestLocale(Locale::getRoot())`
`207`	`206`	`{`
`208`	`207`	`}`
`209`	`208`
`210`		`-BreakIterator::BreakIterator(const BreakIterator &other) : UObject(other) {`
`211`		`- UErrorCode status = U_ZERO_ERROR;`
`212`		`- U_LOCALE_BASED(locBased, *this);`
`213`		`- locBased.setLocaleIDs(other.validLocale, other.actualLocale, status);`
`214`		`- LocaleBased::setLocaleID(other.requestLocale, requestLocale, status);`
`215`		`- U_ASSERT(U_SUCCESS(status));`
	`209`	`+BreakIterator::BreakIterator(const BreakIterator &other)`
	`210`	`+ : UObject(other),`
	`211`	`+ actualLocale(other.actualLocale),`
	`212`	`+ validLocale(other.validLocale),`
	`213`	`+ requestLocale(other.requestLocale) {`
`216`	`214`	`}`
`217`	`215`
`218`	`216`	`BreakIterator &BreakIterator::operator =(const BreakIterator &other) {`
`219`	`217`	`if (this != &other) {`
`220`		`- UErrorCode status = U_ZERO_ERROR;`
`221`		`- U_LOCALE_BASED(locBased, *this);`
`222`		`- locBased.setLocaleIDs(other.validLocale, other.actualLocale, status);`
`223`		`- LocaleBased::setLocaleID(other.requestLocale, requestLocale, status);`
`224`		`- U_ASSERT(U_SUCCESS(status));`
	`218`	`+ actualLocale = other.actualLocale;`
	`219`	`+ validLocale = other.validLocale;`
	`220`	`+ requestLocale = other.requestLocale;`
`225`	`221`	`}`
`226`	`222`	`return *this;`
`227`	`223`	`}`
`228`	`224`
`229`	`225`	`BreakIterator::~BreakIterator()`
`230`	`226`	`{`
`231`		`- delete validLocale;`
`232`		`- delete actualLocale;`
`233`		`- delete requestLocale;`
`234`	`227`	`}`
`235`	`228`
`236`	`229`	`// ------------------------------------------`
`@@ -398,8 +391,8 @@ BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& statu`
`398`	`391`	`// THIS LONG is a sign of bad code -- so the action item is to`
`399`	`392`	`// revisit this in ICU 3.0 and clean it up/fix it/remove it.`
`400`	`393`	`if (U_SUCCESS(status) && (result != nullptr) && *actualLoc.getName() != 0) {`
`401`		`- U_LOCALE_BASED(locBased, *result);`
`402`		`- locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName(), status);`
	`394`	`+ result->actualLocale = actualLoc;`
	`395`	`+ result->validLocale = actualLoc;`
`403`	`396`	`}`
`404`	`397`	`return result;`
`405`	`398`	`}`
`@@ -506,8 +499,7 @@ BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {`
`506`	`499`	`return Locale::getRoot();`
`507`	`500`	`}`
`508`	`501`	`if (type == ULOC_REQUESTED_LOCALE) {`
`509`		`- return requestLocale == nullptr ?`
`510`		`- Locale::getRoot() : Locale(requestLocale->data());`
	`502`	`+ return requestLocale;`
`511`	`503`	`}`
`512`	`504`	`return LocaleBased::getLocale(validLocale, actualLocale, type, status);`
`513`	`505`	`}`
`@@ -518,7 +510,7 @@ BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {`
`518`	`510`	`return nullptr;`
`519`	`511`	`}`
`520`	`512`	`if (type == ULOC_REQUESTED_LOCALE) {`
`521`		`- return requestLocale == nullptr ? "" : requestLocale->data();`
	`513`	`+ return requestLocale.getName();`
`522`	`514`	`}`
`523`	`515`	`return LocaleBased::getLocaleID(validLocale, actualLocale, type, status);`
`524`	`516`	`}`
`@@ -546,11 +538,8 @@ int32_t BreakIterator::getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UE`
`546`	`538`	`return 1;`
`547`	`539`	`}`
`548`	`540`
`549`		`-BreakIterator::BreakIterator (const Locale& valid, const Locale& actual) {`
`550`		`- UErrorCode status = U_ZERO_ERROR;`
`551`		`- U_LOCALE_BASED(locBased, (*this));`
`552`		`- locBased.setLocaleIDs(valid.getName(), actual.getName(), status);`
`553`		`- U_ASSERT(U_SUCCESS(status));`
	`541`	`+BreakIterator::BreakIterator(const Locale& valid, const Locale& actual)`
	`542`	`+ : actualLocale(actual), validLocale(valid), requestLocale(Locale::getRoot()) {`
`554`	`543`	`}`
`555`	`544`
`556`	`545`	`U_NAMESPACE_END`