@nshiab/simple-data-analysis-core 0.0.12

package/script/helpers/rewind.js

@@ -0,0 +1,1295 @@
+"use strict";
+// @ts-nocheck
+// deno-lint-ignore-file
+// Created by bundling the original function with Deno bundle.
+// Original source: @nshiab/journalism-dataviz (d3-geo + d3-array)
+// https://jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/rewind.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewind;
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/ascending.js
+function ascending(a, b) {
+    return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/descending.js
+function descending(a, b) {
+    return a == null || b == null ? NaN : b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/bisector.js
+function bisector(f) {
+    let compare1, compare2, delta;
+    if (f.length !== 2) {
+        compare1 = ascending;
+        compare2 = (d, x) => ascending(f(d), x);
+        delta = (d, x) => f(d) - x;
+    }
+    else {
+        compare1 = f === ascending || f === descending ? f : zero;
+        compare2 = f;
+        delta = f;
+    }
+    function left(a, x, lo = 0, hi = a.length) {
+        if (lo < hi) {
+            if (compare1(x, x) !== 0)
+                return hi;
+            do {
+                const mid = lo + hi >>> 1;
+                if (compare2(a[mid], x) < 0)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            } while (lo < hi);
+        }
+        return lo;
+    }
+    function right(a, x, lo = 0, hi = a.length) {
+        if (lo < hi) {
+            if (compare1(x, x) !== 0)
+                return hi;
+            do {
+                const mid = lo + hi >>> 1;
+                if (compare2(a[mid], x) <= 0)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            } while (lo < hi);
+        }
+        return lo;
+    }
+    function center(a, x, lo = 0, hi = a.length) {
+        const i = left(a, x, lo, hi - 1);
+        return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+    }
+    return {
+        left,
+        center,
+        right
+    };
+}
+function zero() {
+    return 0;
+}
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/number.js
+function number(x) {
+    return x === null ? NaN : +x;
+}
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/bisect.js
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+var bisectLeft = ascendingBisect.left;
+var bisectCenter = bisector(number).center;
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/blur.js
+var blur2 = Blur2(blurf);
+var blurImage = Blur2(blurfImage);
+function Blur2(blur3) {
+    return function (data, rx, ry = rx) {
+        if (!((rx = +rx) >= 0))
+            throw new RangeError("invalid rx");
+        if (!((ry = +ry) >= 0))
+            throw new RangeError("invalid ry");
+        let { data: values, width, height } = data;
+        if (!((width = Math.floor(width)) >= 0))
+            throw new RangeError("invalid width");
+        if (!((height = Math.floor(height !== void 0 ? height : values.length / width)) >= 0))
+            throw new RangeError("invalid height");
+        if (!width || !height || !rx && !ry)
+            return data;
+        const blurx = rx && blur3(rx);
+        const blury = ry && blur3(ry);
+        const temp = values.slice();
+        if (blurx && blury) {
+            blurh(blurx, temp, values, width, height);
+            blurh(blurx, values, temp, width, height);
+            blurh(blurx, temp, values, width, height);
+            blurv(blury, values, temp, width, height);
+            blurv(blury, temp, values, width, height);
+            blurv(blury, values, temp, width, height);
+        }
+        else if (blurx) {
+            blurh(blurx, values, temp, width, height);
+            blurh(blurx, temp, values, width, height);
+            blurh(blurx, values, temp, width, height);
+        }
+        else if (blury) {
+            blurv(blury, values, temp, width, height);
+            blurv(blury, temp, values, width, height);
+            blurv(blury, values, temp, width, height);
+        }
+        return data;
+    };
+}
+function blurh(blur3, T, S, w, h) {
+    for (let y = 0, n = w * h; y < n;) {
+        blur3(T, S, y, y += w, 1);
+    }
+}
+function blurv(blur3, T, S, w, h) {
+    for (let x = 0, n = w * h; x < w; ++x) {
+        blur3(T, S, x, x + n, w);
+    }
+}
+function blurfImage(radius) {
+    const blur3 = blurf(radius);
+    return (T, S, start, stop, step) => {
+        start <<= 2, stop <<= 2, step <<= 2;
+        blur3(T, S, start + 0, stop + 0, step);
+        blur3(T, S, start + 1, stop + 1, step);
+        blur3(T, S, start + 2, stop + 2, step);
+        blur3(T, S, start + 3, stop + 3, step);
+    };
+}
+function blurf(radius) {
+    const radius0 = Math.floor(radius);
+    if (radius0 === radius)
+        return bluri(radius);
+    const t = radius - radius0;
+    const w = 2 * radius + 1;
+    return (T, S, start, stop, step) => {
+        if (!((stop -= step) >= start))
+            return;
+        let sum2 = radius0 * S[start];
+        const s0 = step * radius0;
+        const s1 = s0 + step;
+        for (let i = start, j = start + s0; i < j; i += step) {
+            sum2 += S[Math.min(stop, i)];
+        }
+        for (let i = start, j = stop; i <= j; i += step) {
+            sum2 += S[Math.min(stop, i + s0)];
+            T[i] = (sum2 + t * (S[Math.max(start, i - s1)] + S[Math.min(stop, i + s1)])) / w;
+            sum2 -= S[Math.max(start, i - s0)];
+        }
+    };
+}
+function bluri(radius) {
+    const w = 2 * radius + 1;
+    return (T, S, start, stop, step) => {
+        if (!((stop -= step) >= start))
+            return;
+        let sum2 = radius * S[start];
+        const s = step * radius;
+        for (let i = start, j = start + s; i < j; i += step) {
+            sum2 += S[Math.min(stop, i)];
+        }
+        for (let i = start, j = stop; i <= j; i += step) {
+            sum2 += S[Math.min(stop, i + s)];
+            T[i] = sum2 / w;
+            sum2 -= S[Math.max(start, i - s)];
+        }
+    };
+}
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/fsum.js
+var Adder = class {
+    constructor() {
+        this._partials = new Float64Array(32);
+        this._n = 0;
+    }
+    add(x) {
+        const p = this._partials;
+        let i = 0;
+        for (let j = 0; j < this._n && j < 32; j++) {
+            const y = p[j], hi = x + y, lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
+            if (lo)
+                p[i++] = lo;
+            x = hi;
+        }
+        p[i] = x;
+        this._n = i + 1;
+        return this;
+    }
+    valueOf() {
+        const p = this._partials;
+        let n = this._n, x, y, lo, hi = 0;
+        if (n > 0) {
+            hi = p[--n];
+            while (n > 0) {
+                x = hi;
+                y = p[--n];
+                hi = x + y;
+                lo = y - (hi - x);
+                if (lo)
+                    break;
+            }
+            if (n > 0 && (lo < 0 && p[n - 1] < 0 || lo > 0 && p[n - 1] > 0)) {
+                y = lo * 2;
+                x = hi + y;
+                if (y == x - hi)
+                    hi = x;
+            }
+        }
+        return hi;
+    }
+};
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/array.js
+var array = Array.prototype;
+var slice = array.slice;
+var map = array.map;
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/ticks.js
+var e10 = Math.sqrt(50);
+var e5 = Math.sqrt(10);
+var e2 = Math.sqrt(2);
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/merge.js
+function* flatten(arrays) {
+    for (const array2 of arrays) {
+        yield* array2;
+    }
+}
+function merge(arrays) {
+    return Array.from(flatten(arrays));
+}
+// node_modules/.deno/d3-array@3.2.4/node_modules/d3-array/src/shuffle.js
+var shuffle_default = shuffler(Math.random);
+function shuffler(random) {
+    return function shuffle(array2, i0 = 0, i1 = array2.length) {
+        let m = i1 - (i0 = +i0);
+        while (m) {
+            const i = random() * m-- | 0, t = array2[m + i0];
+            array2[m + i0] = array2[i + i0];
+            array2[i + i0] = t;
+        }
+        return array2;
+    };
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/math.js
+var epsilon = 1e-6;
+var epsilon2 = 1e-12;
+var pi = Math.PI;
+var halfPi = pi / 2;
+var quarterPi = pi / 4;
+var tau = pi * 2;
+var degrees = 180 / pi;
+var radians = pi / 180;
+var abs = Math.abs;
+var atan = Math.atan;
+var atan2 = Math.atan2;
+var cos = Math.cos;
+var exp = Math.exp;
+var log = Math.log;
+var sin = Math.sin;
+var sign = Math.sign || function (x) {
+    return x > 0 ? 1 : x < 0 ? -1 : 0;
+};
+var sqrt = Math.sqrt;
+var tan = Math.tan;
+function acos(x) {
+    return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+}
+function asin(x) {
+    return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/noop.js
+function noop() {
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/stream.js
+function streamGeometry(geometry, stream) {
+    if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {
+        streamGeometryType[geometry.type](geometry, stream);
+    }
+}
+var streamObjectType = {
+    Feature: function (object2, stream) {
+        streamGeometry(object2.geometry, stream);
+    },
+    FeatureCollection: function (object2, stream) {
+        var features = object2.features, i = -1, n = features.length;
+        while (++i < n)
+            streamGeometry(features[i].geometry, stream);
+    }
+};
+var streamGeometryType = {
+    Sphere: function (object2, stream) {
+        stream.sphere();
+    },
+    Point: function (object2, stream) {
+        object2 = object2.coordinates;
+        stream.point(object2[0], object2[1], object2[2]);
+    },
+    MultiPoint: function (object2, stream) {
+        var coordinates2 = object2.coordinates, i = -1, n = coordinates2.length;
+        while (++i < n)
+            object2 = coordinates2[i], stream.point(object2[0], object2[1], object2[2]);
+    },
+    LineString: function (object2, stream) {
+        streamLine(object2.coordinates, stream, 0);
+    },
+    MultiLineString: function (object2, stream) {
+        var coordinates2 = object2.coordinates, i = -1, n = coordinates2.length;
+        while (++i < n)
+            streamLine(coordinates2[i], stream, 0);
+    },
+    Polygon: function (object2, stream) {
+        streamPolygon(object2.coordinates, stream);
+    },
+    MultiPolygon: function (object2, stream) {
+        var coordinates2 = object2.coordinates, i = -1, n = coordinates2.length;
+        while (++i < n)
+            streamPolygon(coordinates2[i], stream);
+    },
+    GeometryCollection: function (object2, stream) {
+        var geometries = object2.geometries, i = -1, n = geometries.length;
+        while (++i < n)
+            streamGeometry(geometries[i], stream);
+    }
+};
+function streamLine(coordinates2, stream, closed) {
+    var i = -1, n = coordinates2.length - closed, coordinate;
+    stream.lineStart();
+    while (++i < n)
+        coordinate = coordinates2[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
+    stream.lineEnd();
+}
+function streamPolygon(coordinates2, stream) {
+    var i = -1, n = coordinates2.length;
+    stream.polygonStart();
+    while (++i < n)
+        streamLine(coordinates2[i], stream, 1);
+    stream.polygonEnd();
+}
+function stream_default(object2, stream) {
+    if (object2 && streamObjectType.hasOwnProperty(object2.type)) {
+        streamObjectType[object2.type](object2, stream);
+    }
+    else {
+        streamGeometry(object2, stream);
+    }
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/area.js
+var areaRingSum = new Adder();
+var areaSum = new Adder();
+var lambda00;
+var phi00;
+var lambda0;
+var cosPhi0;
+var sinPhi0;
+var areaStream = {
+    point: noop,
+    lineStart: noop,
+    lineEnd: noop,
+    polygonStart: function () {
+        areaRingSum = new Adder();
+        areaStream.lineStart = areaRingStart;
+        areaStream.lineEnd = areaRingEnd;
+    },
+    polygonEnd: function () {
+        var areaRing = +areaRingSum;
+        areaSum.add(areaRing < 0 ? tau + areaRing : areaRing);
+        this.lineStart = this.lineEnd = this.point = noop;
+    },
+    sphere: function () {
+        areaSum.add(tau);
+    }
+};
+function areaRingStart() {
+    areaStream.point = areaPointFirst;
+}
+function areaRingEnd() {
+    areaPoint(lambda00, phi00);
+}
+function areaPointFirst(lambda, phi) {
+    areaStream.point = areaPoint;
+    lambda00 = lambda, phi00 = phi;
+    lambda *= radians, phi *= radians;
+    lambda0 = lambda, cosPhi0 = cos(phi = phi / 2 + quarterPi), sinPhi0 = sin(phi);
+}
+function areaPoint(lambda, phi) {
+    lambda *= radians, phi *= radians;
+    phi = phi / 2 + quarterPi;
+    var dLambda = lambda - lambda0, sdLambda = dLambda >= 0 ? 1 : -1, adLambda = sdLambda * dLambda, cosPhi = cos(phi), sinPhi = sin(phi), k = sinPhi0 * sinPhi, u = cosPhi0 * cosPhi + k * cos(adLambda), v = k * sdLambda * sin(adLambda);
+    areaRingSum.add(atan2(v, u));
+    lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;
+}
+function area_default(object2) {
+    areaSum = new Adder();
+    stream_default(object2, areaStream);
+    return areaSum * 2;
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/cartesian.js
+function cartesian(spherical2) {
+    var lambda = spherical2[0], phi = spherical2[1], cosPhi = cos(phi);
+    return [
+        cosPhi * cos(lambda),
+        cosPhi * sin(lambda),
+        sin(phi)
+    ];
+}
+function cartesianCross(a, b) {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0]
+    ];
+}
+function cartesianNormalizeInPlace(d) {
+    var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+    d[0] /= l, d[1] /= l, d[2] /= l;
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/rotation.js
+function rotationIdentity(lambda, phi) {
+    if (abs(lambda) > pi)
+        lambda -= Math.round(lambda / tau) * tau;
+    return [
+        lambda,
+        phi
+    ];
+}
+rotationIdentity.invert = rotationIdentity;
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/clip/buffer.js
+function buffer_default() {
+    var lines = [], line;
+    return {
+        point: function (x, y, m) {
+            line.push([
+                x,
+                y,
+                m
+            ]);
+        },
+        lineStart: function () {
+            lines.push(line = []);
+        },
+        lineEnd: noop,
+        rejoin: function () {
+            if (lines.length > 1)
+                lines.push(lines.pop().concat(lines.shift()));
+        },
+        result: function () {
+            var result = lines;
+            lines = [];
+            line = null;
+            return result;
+        }
+    };
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/pointEqual.js
+function pointEqual_default(a, b) {
+    return abs(a[0] - b[0]) < epsilon && abs(a[1] - b[1]) < epsilon;
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/clip/rejoin.js
+function Intersection(point, points, other, entry) {
+    this.x = point;
+    this.z = points;
+    this.o = other;
+    this.e = entry;
+    this.v = false;
+    this.n = this.p = null;
+}
+function rejoin_default(segments, compareIntersection2, startInside, interpolate, stream) {
+    var subject = [], clip = [], i, n;
+    segments.forEach(function (segment) {
+        if ((n2 = segment.length - 1) <= 0)
+            return;
+        var n2, p0 = segment[0], p1 = segment[n2], x;
+        if (pointEqual_default(p0, p1)) {
+            if (!p0[2] && !p1[2]) {
+                stream.lineStart();
+                for (i = 0; i < n2; ++i)
+                    stream.point((p0 = segment[i])[0], p0[1]);
+                stream.lineEnd();
+                return;
+            }
+            p1[0] += 2 * epsilon;
+        }
+        subject.push(x = new Intersection(p0, segment, null, true));
+        clip.push(x.o = new Intersection(p0, null, x, false));
+        subject.push(x = new Intersection(p1, segment, null, false));
+        clip.push(x.o = new Intersection(p1, null, x, true));
+    });
+    if (!subject.length)
+        return;
+    clip.sort(compareIntersection2);
+    link(subject);
+    link(clip);
+    for (i = 0, n = clip.length; i < n; ++i) {
+        clip[i].e = startInside = !startInside;
+    }
+    var start = subject[0], points, point;
+    while (1) {
+        var current = start, isSubject = true;
+        while (current.v)
+            if ((current = current.n) === start)
+                return;
+        points = current.z;
+        stream.lineStart();
+        do {
+            current.v = current.o.v = true;
+            if (current.e) {
+                if (isSubject) {
+                    for (i = 0, n = points.length; i < n; ++i)
+                        stream.point((point = points[i])[0], point[1]);
+                }
+                else {
+                    interpolate(current.x, current.n.x, 1, stream);
+                }
+                current = current.n;
+            }
+            else {
+                if (isSubject) {
+                    points = current.p.z;
+                    for (i = points.length - 1; i >= 0; --i)
+                        stream.point((point = points[i])[0], point[1]);
+                }
+                else {
+                    interpolate(current.x, current.p.x, -1, stream);
+                }
+                current = current.p;
+            }
+            current = current.o;
+            points = current.z;
+            isSubject = !isSubject;
+        } while (!current.v);
+        stream.lineEnd();
+    }
+}
+function link(array2) {
+    if (!(n = array2.length))
+        return;
+    var n, i = 0, a = array2[0], b;
+    while (++i < n) {
+        a.n = b = array2[i];
+        b.p = a;
+        a = b;
+    }
+    a.n = b = array2[0];
+    b.p = a;
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/polygonContains.js
+function longitude(point) {
+    return abs(point[0]) <= pi ? point[0] : sign(point[0]) * ((abs(point[0]) + pi) % tau - pi);
+}
+function polygonContains_default(polygon, point) {
+    var lambda = longitude(point), phi = point[1], sinPhi = sin(phi), normal = [
+        sin(lambda),
+        -cos(lambda),
+        0
+    ], angle = 0, winding = 0;
+    var sum2 = new Adder();
+    if (sinPhi === 1)
+        phi = halfPi + epsilon;
+    else if (sinPhi === -1)
+        phi = -halfPi - epsilon;
+    for (var i = 0, n = polygon.length; i < n; ++i) {
+        if (!(m = (ring = polygon[i]).length))
+            continue;
+        var ring, m, point0 = ring[m - 1], lambda03 = longitude(point0), phi0 = point0[1] / 2 + quarterPi, sinPhi03 = sin(phi0), cosPhi03 = cos(phi0);
+        for (var j = 0; j < m; ++j, lambda03 = lambda1, sinPhi03 = sinPhi1, cosPhi03 = cosPhi1, point0 = point1) {
+            var point1 = ring[j], lambda1 = longitude(point1), phi1 = point1[1] / 2 + quarterPi, sinPhi1 = sin(phi1), cosPhi1 = cos(phi1), delta = lambda1 - lambda03, sign2 = delta >= 0 ? 1 : -1, absDelta = sign2 * delta, antimeridian = absDelta > pi, k = sinPhi03 * sinPhi1;
+            sum2.add(atan2(k * sign2 * sin(absDelta), cosPhi03 * cosPhi1 + k * cos(absDelta)));
+            angle += antimeridian ? delta + sign2 * tau : delta;
+            if (antimeridian ^ lambda03 >= lambda ^ lambda1 >= lambda) {
+                var arc = cartesianCross(cartesian(point0), cartesian(point1));
+                cartesianNormalizeInPlace(arc);
+                var intersection2 = cartesianCross(normal, arc);
+                cartesianNormalizeInPlace(intersection2);
+                var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection2[2]);
+                if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
+                    winding += antimeridian ^ delta >= 0 ? 1 : -1;
+                }
+            }
+        }
+    }
+    return (angle < -epsilon || angle < epsilon && sum2 < -epsilon2) ^ winding & 1;
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/clip/index.js
+function clip_default(pointVisible, clipLine, interpolate, start) {
+    return function (sink) {
+        var line = clipLine(sink), ringBuffer = buffer_default(), ringSink = clipLine(ringBuffer), polygonStarted = false, polygon, segments, ring;
+        var clip = {
+            point,
+            lineStart,
+            lineEnd,
+            polygonStart: function () {
+                clip.point = pointRing;
+                clip.lineStart = ringStart;
+                clip.lineEnd = ringEnd;
+                segments = [];
+                polygon = [];
+            },
+            polygonEnd: function () {
+                clip.point = point;
+                clip.lineStart = lineStart;
+                clip.lineEnd = lineEnd;
+                segments = merge(segments);
+                var startInside = polygonContains_default(polygon, start);
+                if (segments.length) {
+                    if (!polygonStarted)
+                        sink.polygonStart(), polygonStarted = true;
+                    rejoin_default(segments, compareIntersection, startInside, interpolate, sink);
+                }
+                else if (startInside) {
+                    if (!polygonStarted)
+                        sink.polygonStart(), polygonStarted = true;
+                    sink.lineStart();
+                    interpolate(null, null, 1, sink);
+                    sink.lineEnd();
+                }
+                if (polygonStarted)
+                    sink.polygonEnd(), polygonStarted = false;
+                segments = polygon = null;
+            },
+            sphere: function () {
+                sink.polygonStart();
+                sink.lineStart();
+                interpolate(null, null, 1, sink);
+                sink.lineEnd();
+                sink.polygonEnd();
+            }
+        };
+        function point(lambda, phi) {
+            if (pointVisible(lambda, phi))
+                sink.point(lambda, phi);
+        }
+        function pointLine(lambda, phi) {
+            line.point(lambda, phi);
+        }
+        function lineStart() {
+            clip.point = pointLine;
+            line.lineStart();
+        }
+        function lineEnd() {
+            clip.point = point;
+            line.lineEnd();
+        }
+        function pointRing(lambda, phi) {
+            ring.push([
+                lambda,
+                phi
+            ]);
+            ringSink.point(lambda, phi);
+        }
+        function ringStart() {
+            ringSink.lineStart();
+            ring = [];
+        }
+        function ringEnd() {
+            pointRing(ring[0][0], ring[0][1]);
+            ringSink.lineEnd();
+            var clean = ringSink.clean(), ringSegments = ringBuffer.result(), i, n = ringSegments.length, m, segment, point2;
+            ring.pop();
+            polygon.push(ring);
+            ring = null;
+            if (!n)
+                return;
+            if (clean & 1) {
+                segment = ringSegments[0];
+                if ((m = segment.length - 1) > 0) {
+                    if (!polygonStarted)
+                        sink.polygonStart(), polygonStarted = true;
+                    sink.lineStart();
+                    for (i = 0; i < m; ++i)
+                        sink.point((point2 = segment[i])[0], point2[1]);
+                    sink.lineEnd();
+                }
+                return;
+            }
+            if (n > 1 && clean & 2)
+                ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+            segments.push(ringSegments.filter(validSegment));
+        }
+        return clip;
+    };
+}
+function validSegment(segment) {
+    return segment.length > 1;
+}
+function compareIntersection(a, b) {
+    return ((a = a.x)[0] < 0 ? a[1] - halfPi - epsilon : halfPi - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi - epsilon : halfPi - b[1]);
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/clip/antimeridian.js
+var antimeridian_default = clip_default(function () {
+    return true;
+}, clipAntimeridianLine, clipAntimeridianInterpolate, [
+    -pi,
+    -halfPi
+]);
+function clipAntimeridianLine(stream) {
+    var lambda03 = NaN, phi0 = NaN, sign0 = NaN, clean;
+    return {
+        lineStart: function () {
+            stream.lineStart();
+            clean = 1;
+        },
+        point: function (lambda1, phi1) {
+            var sign1 = lambda1 > 0 ? pi : -pi, delta = abs(lambda1 - lambda03);
+            if (abs(delta - pi) < epsilon) {
+                stream.point(lambda03, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi : -halfPi);
+                stream.point(sign0, phi0);
+                stream.lineEnd();
+                stream.lineStart();
+                stream.point(sign1, phi0);
+                stream.point(lambda1, phi0);
+                clean = 0;
+            }
+            else if (sign0 !== sign1 && delta >= pi) {
+                if (abs(lambda03 - sign0) < epsilon)
+                    lambda03 -= sign0 * epsilon;
+                if (abs(lambda1 - sign1) < epsilon)
+                    lambda1 -= sign1 * epsilon;
+                phi0 = clipAntimeridianIntersect(lambda03, phi0, lambda1, phi1);
+                stream.point(sign0, phi0);
+                stream.lineEnd();
+                stream.lineStart();
+                stream.point(sign1, phi0);
+                clean = 0;
+            }
+            stream.point(lambda03 = lambda1, phi0 = phi1);
+            sign0 = sign1;
+        },
+        lineEnd: function () {
+            stream.lineEnd();
+            lambda03 = phi0 = NaN;
+        },
+        clean: function () {
+            return 2 - clean;
+        }
+    };
+}
+function clipAntimeridianIntersect(lambda03, phi0, lambda1, phi1) {
+    var cosPhi03, cosPhi1, sinLambda0Lambda1 = sin(lambda03 - lambda1);
+    return abs(sinLambda0Lambda1) > epsilon ? atan((sin(phi0) * (cosPhi1 = cos(phi1)) * sin(lambda1) - sin(phi1) * (cosPhi03 = cos(phi0)) * sin(lambda03)) / (cosPhi03 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
+}
+function clipAntimeridianInterpolate(from, to, direction, stream) {
+    var phi;
+    if (from == null) {
+        phi = direction * halfPi;
+        stream.point(-pi, phi);
+        stream.point(0, phi);
+        stream.point(pi, phi);
+        stream.point(pi, 0);
+        stream.point(pi, -phi);
+        stream.point(0, -phi);
+        stream.point(-pi, -phi);
+        stream.point(-pi, 0);
+        stream.point(-pi, phi);
+    }
+    else if (abs(from[0] - to[0]) > epsilon) {
+        var lambda = from[0] < to[0] ? pi : -pi;
+        phi = direction * lambda / 2;
+        stream.point(-lambda, phi);
+        stream.point(0, phi);
+        stream.point(lambda, phi);
+    }
+    else {
+        stream.point(to[0], to[1]);
+    }
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/clip/rectangle.js
+var clipMax = 1e9;
+var clipMin = -clipMax;
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/length.js
+var lengthSum;
+var lambda02;
+var sinPhi02;
+var cosPhi02;
+var lengthStream = {
+    sphere: noop,
+    point: noop,
+    lineStart: lengthLineStart,
+    lineEnd: noop,
+    polygonStart: noop,
+    polygonEnd: noop
+};
+function lengthLineStart() {
+    lengthStream.point = lengthPointFirst;
+    lengthStream.lineEnd = lengthLineEnd;
+}
+function lengthLineEnd() {
+    lengthStream.point = lengthStream.lineEnd = noop;
+}
+function lengthPointFirst(lambda, phi) {
+    lambda *= radians, phi *= radians;
+    lambda02 = lambda, sinPhi02 = sin(phi), cosPhi02 = cos(phi);
+    lengthStream.point = lengthPoint;
+}
+function lengthPoint(lambda, phi) {
+    lambda *= radians, phi *= radians;
+    var sinPhi = sin(phi), cosPhi = cos(phi), delta = abs(lambda - lambda02), cosDelta = cos(delta), sinDelta = sin(delta), x = cosPhi * sinDelta, y = cosPhi02 * sinPhi - sinPhi02 * cosPhi * cosDelta, z = sinPhi02 * sinPhi + cosPhi02 * cosPhi * cosDelta;
+    lengthSum.add(atan2(sqrt(x * x + y * y), z));
+    lambda02 = lambda, sinPhi02 = sinPhi, cosPhi02 = cosPhi;
+}
+function length_default(object2) {
+    lengthSum = new Adder();
+    stream_default(object2, lengthStream);
+    return +lengthSum;
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/distance.js
+var coordinates = [
+    null,
+    null
+];
+var object = {
+    type: "LineString",
+    coordinates
+};
+function distance_default(a, b) {
+    coordinates[0] = a;
+    coordinates[1] = b;
+    return length_default(object);
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/contains.js
+var containsObjectType = {
+    Feature: function (object2, point) {
+        return containsGeometry(object2.geometry, point);
+    },
+    FeatureCollection: function (object2, point) {
+        var features = object2.features, i = -1, n = features.length;
+        while (++i < n)
+            if (containsGeometry(features[i].geometry, point))
+                return true;
+        return false;
+    }
+};
+var containsGeometryType = {
+    Sphere: function () {
+        return true;
+    },
+    Point: function (object2, point) {
+        return containsPoint(object2.coordinates, point);
+    },
+    MultiPoint: function (object2, point) {
+        var coordinates2 = object2.coordinates, i = -1, n = coordinates2.length;
+        while (++i < n)
+            if (containsPoint(coordinates2[i], point))
+                return true;
+        return false;
+    },
+    LineString: function (object2, point) {
+        return containsLine(object2.coordinates, point);
+    },
+    MultiLineString: function (object2, point) {
+        var coordinates2 = object2.coordinates, i = -1, n = coordinates2.length;
+        while (++i < n)
+            if (containsLine(coordinates2[i], point))
+                return true;
+        return false;
+    },
+    Polygon: function (object2, point) {
+        return containsPolygon(object2.coordinates, point);
+    },
+    MultiPolygon: function (object2, point) {
+        var coordinates2 = object2.coordinates, i = -1, n = coordinates2.length;
+        while (++i < n)
+            if (containsPolygon(coordinates2[i], point))
+                return true;
+        return false;
+    },
+    GeometryCollection: function (object2, point) {
+        var geometries = object2.geometries, i = -1, n = geometries.length;
+        while (++i < n)
+            if (containsGeometry(geometries[i], point))
+                return true;
+        return false;
+    }
+};
+function containsGeometry(geometry, point) {
+    return geometry && containsGeometryType.hasOwnProperty(geometry.type) ? containsGeometryType[geometry.type](geometry, point) : false;
+}
+function containsPoint(coordinates2, point) {
+    return distance_default(coordinates2, point) === 0;
+}
+function containsLine(coordinates2, point) {
+    var ao, bo, ab;
+    for (var i = 0, n = coordinates2.length; i < n; i++) {
+        bo = distance_default(coordinates2[i], point);
+        if (bo === 0)
+            return true;
+        if (i > 0) {
+            ab = distance_default(coordinates2[i], coordinates2[i - 1]);
+            if (ab > 0 && ao <= ab && bo <= ab && (ao + bo - ab) * (1 - Math.pow((ao - bo) / ab, 2)) < epsilon2 * ab)
+                return true;
+        }
+        ao = bo;
+    }
+    return false;
+}
+function containsPolygon(coordinates2, point) {
+    return !!polygonContains_default(coordinates2.map(ringRadians), pointRadians(point));
+}
+function ringRadians(ring) {
+    return ring = ring.map(pointRadians), ring.pop(), ring;
+}
+function pointRadians(point) {
+    return [
+        point[0] * radians,
+        point[1] * radians
+    ];
+}
+function contains_default(object2, point) {
+    return (object2 && containsObjectType.hasOwnProperty(object2.type) ? containsObjectType[object2.type] : containsGeometry)(object2, point);
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/path/area.js
+var areaSum2 = new Adder();
+var areaRingSum2 = new Adder();
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/path/bounds.js
+var x0 = Infinity;
+var x1 = -x0;
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/path/context.js
+function PathContext(context) {
+    this._context = context;
+}
+PathContext.prototype = {
+    _radius: 4.5,
+    pointRadius: function (_) {
+        return this._radius = _, this;
+    },
+    polygonStart: function () {
+        this._line = 0;
+    },
+    polygonEnd: function () {
+        this._line = NaN;
+    },
+    lineStart: function () {
+        this._point = 0;
+    },
+    lineEnd: function () {
+        if (this._line === 0)
+            this._context.closePath();
+        this._point = NaN;
+    },
+    point: function (x, y) {
+        switch (this._point) {
+            case 0: {
+                this._context.moveTo(x, y);
+                this._point = 1;
+                break;
+            }
+            case 1: {
+                this._context.lineTo(x, y);
+                break;
+            }
+            default: {
+                this._context.moveTo(x + this._radius, y);
+                this._context.arc(x, y, this._radius, 0, tau);
+                break;
+            }
+        }
+    },
+    result: noop
+};
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/path/measure.js
+var lengthSum2 = new Adder();
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/transform.js
+function transform_default(methods) {
+    return {
+        stream: transformer(methods)
+    };
+}
+function transformer(methods) {
+    return function (stream) {
+        var s = new TransformStream();
+        for (var key in methods)
+            s[key] = methods[key];
+        s.stream = stream;
+        return s;
+    };
+}
+function TransformStream() {
+}
+TransformStream.prototype = {
+    constructor: TransformStream,
+    point: function (x, y) {
+        this.stream.point(x, y);
+    },
+    sphere: function () {
+        this.stream.sphere();
+    },
+    lineStart: function () {
+        this.stream.lineStart();
+    },
+    lineEnd: function () {
+        this.stream.lineEnd();
+    },
+    polygonStart: function () {
+        this.stream.polygonStart();
+    },
+    polygonEnd: function () {
+        this.stream.polygonEnd();
+    }
+};
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/resample.js
+var cosMinDistance = cos(30 * radians);
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/index.js
+var transformRadians = transformer({
+    point: function (x, y) {
+        this.stream.point(x * radians, y * radians);
+    }
+});
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/azimuthal.js
+function azimuthalRaw(scale) {
+    return function (x, y) {
+        var cx = cos(x), cy = cos(y), k = scale(cx * cy);
+        if (k === Infinity)
+            return [
+                2,
+                0
+            ];
+        return [
+            k * cy * sin(x),
+            k * sin(y)
+        ];
+    };
+}
+function azimuthalInvert(angle) {
+    return function (x, y) {
+        var z = sqrt(x * x + y * y), c = angle(z), sc = sin(c), cc = cos(c);
+        return [
+            atan2(x * sc, z * cc),
+            asin(z && y * sc / z)
+        ];
+    };
+}
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/azimuthalEqualArea.js
+var azimuthalEqualAreaRaw = azimuthalRaw(function (cxcy) {
+    return sqrt(2 / (1 + cxcy));
+});
+azimuthalEqualAreaRaw.invert = azimuthalInvert(function (z) {
+    return 2 * asin(z / 2);
+});
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/azimuthalEquidistant.js
+var azimuthalEquidistantRaw = azimuthalRaw(function (c) {
+    return (c = acos(c)) && c / sin(c);
+});
+azimuthalEquidistantRaw.invert = azimuthalInvert(function (z) {
+    return z;
+});
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/mercator.js
+function mercatorRaw(lambda, phi) {
+    return [
+        lambda,
+        log(tan((halfPi + phi) / 2))
+    ];
+}
+mercatorRaw.invert = function (x, y) {
+    return [
+        x,
+        2 * atan(exp(y)) - halfPi
+    ];
+};
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/equirectangular.js
+function equirectangularRaw(lambda, phi) {
+    return [
+        lambda,
+        phi
+    ];
+}
+equirectangularRaw.invert = equirectangularRaw;
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/equalEarth.js
+var A1 = 1.340264;
+var A2 = -0.081106;
+var A3 = 893e-6;
+var A4 = 3796e-6;
+var M = sqrt(3) / 2;
+var iterations = 12;
+function equalEarthRaw(lambda, phi) {
+    var l = asin(M * sin(phi)), l2 = l * l, l6 = l2 * l2 * l2;
+    return [
+        lambda * cos(l) / (M * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))),
+        l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2))
+    ];
+}
+equalEarthRaw.invert = function (x, y) {
+    var l = y, l2 = l * l, l6 = l2 * l2 * l2;
+    for (var i = 0, delta, fy, fpy; i < iterations; ++i) {
+        fy = l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - y;
+        fpy = A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2);
+        l -= delta = fy / fpy, l2 = l * l, l6 = l2 * l2 * l2;
+        if (abs(delta) < epsilon2)
+            break;
+    }
+    return [
+        M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2)) / cos(l),
+        asin(sin(l) / M)
+    ];
+};
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/gnomonic.js
+function gnomonicRaw(x, y) {
+    var cy = cos(y), k = cos(x) * cy;
+    return [
+        cy * sin(x) / k,
+        sin(y) / k
+    ];
+}
+gnomonicRaw.invert = azimuthalInvert(atan);
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/naturalEarth1.js
+function naturalEarth1Raw(lambda, phi) {
+    var phi2 = phi * phi, phi4 = phi2 * phi2;
+    return [
+        lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (3971e-6 * phi2 - 1529e-6 * phi4))),
+        phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 5916e-6 * phi4)))
+    ];
+}
+naturalEarth1Raw.invert = function (x, y) {
+    var phi = y, i = 25, delta;
+    do {
+        var phi2 = phi * phi, phi4 = phi2 * phi2;
+        phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 5916e-6 * phi4))) - y) / (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 5916e-6 * 11 * phi4)));
+    } while (abs(delta) > epsilon && --i > 0);
+    return [
+        x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (3971e-6 - 1529e-6 * phi2)))),
+        phi
+    ];
+};
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/orthographic.js
+function orthographicRaw(x, y) {
+    return [
+        cos(y) * sin(x),
+        sin(y)
+    ];
+}
+orthographicRaw.invert = azimuthalInvert(asin);
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/stereographic.js
+function stereographicRaw(x, y) {
+    var cy = cos(y), k = 1 + cos(x) * cy;
+    return [
+        cy * sin(x) / k,
+        sin(y) / k
+    ];
+}
+stereographicRaw.invert = azimuthalInvert(function (z) {
+    return 2 * atan(z);
+});
+// node_modules/.deno/d3-geo@3.1.1/node_modules/d3-geo/src/projection/transverseMercator.js
+function transverseMercatorRaw(lambda, phi) {
+    return [
+        log(tan((halfPi + phi) / 2)),
+        -lambda
+    ];
+}
+transverseMercatorRaw.invert = function (x, y) {
+    return [
+        -y,
+        2 * atan(exp(x)) - halfPi
+    ];
+};
+// deno:https://jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/rewind.ts
+function rewind(object2) {
+    const projection2 = geoRewindStream();
+    const stream = projection2.stream;
+    let project;
+    if (!stream)
+        throw new Error("invalid projection");
+    switch (object2 && object2.type) {
+        case "Feature":
+            project = projectFeature;
+            break;
+        case "FeatureCollection":
+            project = projectFeatureCollection;
+            break;
+        default:
+            project = projectGeometry;
+            break;
+    }
+    return project(object2, stream);
+}
+function geoRewindStream() {
+    let ring;
+    let polygon;
+    return transform_default({
+        polygonStart() {
+            this.stream.polygonStart();
+            polygon = [];
+        },
+        lineStart() {
+            if (polygon)
+                polygon.push(ring = []);
+            else
+                this.stream.lineStart();
+        },
+        lineEnd() {
+            if (!polygon)
+                this.stream.lineEnd();
+        },
+        point(x, y) {
+            if (polygon)
+                ring.push([
+                    x,
+                    y
+                ]);
+            else
+                this.stream.point(x, y);
+        },
+        polygonEnd() {
+            for (const [i, ring2] of polygon.entries()) {
+                ring2.push(ring2[0].slice());
+                if (i ? !contains_default({
+                    type: "Polygon",
+                    coordinates: [
+                        ring2
+                    ]
+                }, 
+                // @ts-ignore To do
+                polygon[0][0]) : polygon[1] ? !contains_default({
+                    type: "Polygon",
+                    coordinates: [
+                        ring2
+                    ]
+                }, 
+                // @ts-ignore To do
+                polygon[1][0]) : area_default({
+                    type: "Polygon",
+                    coordinates: [
+                        ring2
+                    ]
+                }) > 2 * Math.PI) {
+                    ring2.reverse();
+                }
+                this.stream.lineStart();
+                ring2.pop();
+                for (const [x, y] of ring2)
+                    this.stream.point(x, y);
+                this.stream.lineEnd();
+            }
+            this.stream.polygonEnd();
+            polygon = null;
+        }
+    });
+}
+function projectFeatureCollection(o, stream) {
+    return {
+        ...o,
+        features: o.features.map((f) => projectFeature(f, stream))
+    };
+}
+function projectFeature(o, stream) {
+    return {
+        ...o,
+        geometry: projectGeometry(o.geometry, stream)
+    };
+}
+function projectGeometryCollection(o, stream) {
+    return {
+        ...o,
+        // @ts-ignore To do
+        geometries: o.geometries.map((o2) => projectGeometry(o2, stream))
+    };
+}
+function projectGeometry(o, stream) {
+    return !o ? null : o.type === "GeometryCollection" ? projectGeometryCollection(o, stream) : o.type === "Polygon" || o.type === "MultiPolygon" ? projectPolygons(o, stream) : o;
+}
+function projectPolygons(o, stream) {
+    let coordinates2 = [];
+    let polygon, line;
+    stream_default(o, stream({
+        polygonStart() {
+            coordinates2.push(polygon = []);
+        },
+        polygonEnd() {
+        },
+        lineStart() {
+            polygon.push(line = []);
+        },
+        lineEnd() {
+            line.push(line[0].slice());
+        },
+        // @ts-ignore To do
+        point(x, y) {
+            line.push([
+                x,
+                y
+            ]);
+        }
+    }));
+    if (o.type === "Polygon")
+        coordinates2 = coordinates2[0];
+    return {
+        ...o,
+        coordinates: coordinates2
+    };
+}