1 files changed, 0 insertions, 160 deletions
diff --git a/deps/node/deps/icu-small/source/tools/toolutil/denseranges.cpp b/deps/node/deps/icu-small/source/tools/toolutil/denseranges.cpp
deleted file mode 100644
index f5e52b1b..00000000
--- a/deps/node/deps/icu-small/source/tools/toolutil/denseranges.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-*   Copyright (C) 2010, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*******************************************************************************
-*   file name:  denseranges.cpp
-*   encoding:   UTF-8
-*   tab size:   8 (not used)
-*   indentation:4
-*
-*   created on: 2010sep25
-*   created by: Markus W. Scherer
-*
-* Helper code for finding a small number of dense ranges.
-*/
-
-#include "unicode/utypes.h"
-#include "denseranges.h"
-
-// Definitions in the anonymous namespace are invisible outside this file.
-namespace {
-
-/**
- * Collect up to 15 range gaps and sort them by ascending gap size.
- */
-class LargestGaps {
-public:
-    LargestGaps(int32_t max) : maxLength(max<=kCapacity ? max : kCapacity), length(0) {}
-
-    void add(int32_t gapStart, int64_t gapLength) {
-        int32_t i=length;
-        while(i>0 && gapLength>gapLengths[i-1]) {
-            --i;
-        }
-        if(i<maxLength) {
-            // The new gap is now one of the maxLength largest.
-            // Insert the new gap, moving up smaller ones of the previous
-            // length largest.
-            int32_t j= length<maxLength ? length++ : maxLength-1;
-            while(j>i) {
-                gapStarts[j]=gapStarts[j-1];
-                gapLengths[j]=gapLengths[j-1];
-                --j;
-            }
-            gapStarts[i]=gapStart;
-            gapLengths[i]=gapLength;
-        }
-    }
-
-    void truncate(int32_t newLength) {
-        if(newLength<length) {
-            length=newLength;
-        }
-    }
-
-    int32_t count() const { return length; }
-    int32_t gapStart(int32_t i) const { return gapStarts[i]; }
-    int64_t gapLength(int32_t i) const { return gapLengths[i]; }
-
-    int32_t firstAfter(int32_t value) const {
-        if(length==0) {
-            return -1;
-        }
-        int32_t minValue=0;
-        int32_t minIndex=-1;
-        for(int32_t i=0; i<length; ++i) {
-            if(value<gapStarts[i] && (minIndex<0 || gapStarts[i]<minValue)) {
-                minValue=gapStarts[i];
-                minIndex=i;
-            }
-        }
-        return minIndex;
-    }
-
-private:
-    static const int32_t kCapacity=15;
-
-    int32_t maxLength;
-    int32_t length;
-    int32_t gapStarts[kCapacity];
-    int64_t gapLengths[kCapacity];
-};
-
-}  // namespace
-
-/**
- * Does it make sense to write 1..capacity ranges?
- * Returns 0 if not, otherwise the number of ranges.
- * @param values Sorted array of signed-integer values.
- * @param length Number of values.
- * @param density Minimum average range density, in 256th. (0x100=100%=perfectly dense.)
- *                Should be 0x80..0x100, must be 1..0x100.
- * @param ranges Output ranges array.
- * @param capacity Maximum number of ranges.
- * @return Minimum number of ranges (at most capacity) that have the desired density,
- *         or 0 if that density cannot be achieved.
- */
-U_CAPI int32_t U_EXPORT2
-uprv_makeDenseRanges(const int32_t values[], int32_t length,
-                     int32_t density,
-                     int32_t ranges[][2], int32_t capacity) {
-    if(length<=2) {
-        return 0;
-    }
-    int32_t minValue=values[0];
-    int32_t maxValue=values[length-1];  // Assume minValue<=maxValue.
-    // Use int64_t variables for intermediate-value precision and to avoid
-    // signed-int32_t overflow of maxValue-minValue.
-    int64_t maxLength=(int64_t)maxValue-(int64_t)minValue+1;
-    if(length>=(density*maxLength)/0x100) {
-        // Use one range.
-        ranges[0][0]=minValue;
-        ranges[0][1]=maxValue;
-        return 1;
-    }
-    if(length<=4) {
-        return 0;
-    }
-    // See if we can split [minValue, maxValue] into 2..capacity ranges,
-    // divided by the 1..(capacity-1) largest gaps.
-    LargestGaps gaps(capacity-1);
-    int32_t i;
-    int32_t expectedValue=minValue;
-    for(i=1; i<length; ++i) {
-        ++expectedValue;
-        int32_t actualValue=values[i];
-        if(expectedValue!=actualValue) {
-            gaps.add(expectedValue, (int64_t)actualValue-(int64_t)expectedValue);
-            expectedValue=actualValue;
-        }
-    }
-    // We know gaps.count()>=1 because we have fewer values (length) than
-    // the length of the [minValue..maxValue] range (maxLength).
-    // (Otherwise we would have returned with the one range above.)
-    int32_t num;
-    for(i=0, num=2;; ++i, ++num) {
-        if(i>=gaps.count()) {
-            // The values are too sparse for capacity or fewer ranges
-            // of the requested density.
-            return 0;
-        }
-        maxLength-=gaps.gapLength(i);
-        if(length>num*2 && length>=(density*maxLength)/0x100) {
-            break;
-        }
-    }
-    // Use the num ranges with the num-1 largest gaps.
-    gaps.truncate(num-1);
-    ranges[0][0]=minValue;
-    for(i=0; i<=num-2; ++i) {
-        int32_t gapIndex=gaps.firstAfter(minValue);
-        int32_t gapStart=gaps.gapStart(gapIndex);
-        ranges[i][1]=gapStart-1;
-        ranges[i+1][0]=minValue=(int32_t)(gapStart+gaps.gapLength(gapIndex));
-    }
-    ranges[num-1][1]=maxValue;
-    return num;
-}