https://www.hai-furi.com/assets_mv/js/lib/pixi-legacy.js

1325 i += dim) { last = insertNode(i, data[i], data[i + 1], last); }
1326	    } else {
1327	        for (i = end - dim; i >= start; i -= dim) { last = insertNode(i, data[i], data[i + 1], last); }
1328	    }
1329
1330	    if (last && equals(last, last.next)) {
1331	        removeNode(last);
1332	        last = last.next;
1333	    }
1334
1335	    return last;
1336	}
1337
1338	// eliminate colinear or duplicate points
1339	function filterPoints(start, end) {
1340	    if (!start) { return start; }
1341	    if (!end) { end = start; }
1342
1343	    var p = start,
1344	        again;
1345	    do {
1346	        again = false;
1347
1348	        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
1349	            removeNode(p);
1350	            p = end = p.prev;
1351	            if (p === p.next) { break; }
1352	            again = true;
1353
1354	        } else {
1355	            p = p.next;
1356	        }
1357	    } while (again || p !== end);
1358
1359	    return end;
1360	}
1361
1362	// main ear slicing loop which triangulates a polygon (given as a linked list)
1363	function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
1364	    if (!ear) { return; }
1365
1366	    // interlink polygon nodes in z-order
1367	    if (!pass && invSize) { indexCurve(ear, minX, minY, invSize); }
1368
1369	    var stop = ear,
1370	        prev, next;
1371
1372	    // iterate through ears, slicing them one by one
1373	    while (ear.prev !== ear.next) {
1374	        prev = ear.prev;
1375	        next = ear.next;
1376
1377	        if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
1378	            // cut off the triangle
1379	            triangles.push(prev.i / dim);
1380	            triangles.push(ear.i / dim);
1381	            triangles.push(next.i / dim);
1382
1383	            removeNode(ear);
1384
1385	            // skipping the next vertex leads to less sliver triangles
1386	            ear = next.next;
1387	            stop = next.next;
1388
1389	            continue;
1390	        }
1391
1392	        ear = next;
1393
1394	        // if we looped through the whole remaining polygon and can't find any more ears
1395	        if (ear === stop) {
1396	            // try filtering points and slicing again
1397	            if (!pass) {
1398	                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
1399
1400	            // if this didn't work, try curing all small self-intersections locally
1401	            } else if (pass === 1) {
1402	                ear = cureLocalIntersections(ear, triangles, dim);
1403	                earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
1404
1405	            // as a last resort, try splitting the remaining polygon into two
1406	            } else if (pass === 2) {
1407	                splitEarcut(ear, triangles, dim, minX, minY, invSize);
1408	            }
1409
1410	            break;
1411	        }
1412	    }
1413	}
1414
1415	// check whether a polygon node forms a valid ear with adjacent nodes
1416	function isEar(ear) {
1417	    var a = ear.prev,
1418	        b = ear,
1419	        c = ear.next;
1420
1421	    if (area(a, b, c) >= 0) { return false; } // reflex, can't be an ear
1422
1423	    // now make sure we don't have other points inside the potential ear
1424	    var p = ear.next.next;
1425
1426	    while (p !== ear.prev) {
1427	        if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
1428	            area(p.prev, p, p.next) >= 0) { return false; }
1429	        p = p.next;
1430	    }
1431
1432	    return true;
1433	}
1434
1435	function isEarHashed(ear, minX, minY, invSize) {
1436	    var a = ear.prev,
1437	        b = ear,
1438	        c = ear.next;
1439
1440	    if (area(a, b, c) >= 0) { return false; } // reflex, can't be an ear
1441
1442	    // triangle bbox; min & max are calculated like this for speed
1443	    var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x),
1444	        minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y),
1445	        maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x),
1446	        maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y);
1447
1448	    // z-order range for the current triangle bbox;
1449	    var minZ = zOrder(minTX, minTY, minX, minY, invSize),
1450	        maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
1451
1452	    var p = ear.prevZ,
1453	        n = ear.nextZ;
1454
1455	    // look for points inside the triangle in both directions
1456	    while (p && p.z >= minZ && n && n.z <= maxZ) {
1457	        if (p !== ear.prev && p !== ear.next &&
1458	            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
1459	            area(p.prev, p, p.next) >= 0) { return false; }
1460	        p = p.prevZ;
1461
1462	        if (n !== ear.prev && n !== ear.next &&
1463	            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
1464	            area(n.prev, n, n.next) >= 0) { return false; }
1465	        n = n.nextZ;
1466	    }
1467
1468	    // look for remaining points in decreasing z-order
1469	    while (p && p.z >= minZ) {
1470	        if (p !== ear.prev && p !== ear.next &&
1471	            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
1472	            area(p.prev, p, p.next) >= 0) { return false; }
1473	        p = p.prevZ;
1474	    }
1475
1476	    // look for remaining points in increasing z-order
1477	    while (n && n.z <= maxZ) {
1478	        if (n !== ear.prev && n !== ear.next &&
1479	            pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
1480	            area(n.prev, n, n.next) >= 0) { return false; }
1481	        n = n.nextZ;
1482	    }
1483
1484	    return true;
1485	}
1486
1487	// go through all polygon nodes and cure small local self-intersections
1488	function cureLocalIntersections(start, triangles, dim) {
1489	    var p = start;
1490	    do {
1491	        var a = p.prev,
1492	            b = p.next.next;
1493
1494	        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
1495
1496	            triangles.push(a.i / dim);
1497	            triangles.push(p.i / dim);
1498	            triangles.push(b.i / dim);
1499
1500	            // remove two nodes involved
1501	            removeNode(p);
1502	            removeNode(p.next);
1503
1504	            p = start = b;
1505	        }
1506	        p = p.next;
1507	    } while (p !== start);
1508
1509	    return p;
1510	}
1511
1512	// try splitting polygon into two and triangulate them independently
1513	function splitEarcut(start, triangles, dim, minX, minY, invSize) {
1514	    // look for a valid diagonal that divides the polygon into two
1515	    var a = start;
1516	    do {
1517	        var b = a.next.next;
1518	        while (b !== a.prev) {
1519	            if (a.i !== b.i && isValidDiagonal(a, b)) {
1520	                // split the polygon in two by the diagonal
1521	                var c = splitPolygon(a, b);
1522
1523	                // filter colinear points around the cuts
1524	                a = filterPoints(a, a.next);
1525	                c = filterPoints(c, c.next);
1526
1527	                // run earcut on each half
1528	                earcutLinked(a, triangles, dim, minX, minY, invSize);
1529	                earcutLinked(c, triangles, dim, minX, minY, invSize);
1530	                return;
1531	            }
1532	            b = b.next;
1533	        }
1534	        a = a.next;
1535	    } while (a !== start);
1536	}
1537
1538	// link every hole into the outer loop, producing a single-ring polygon without holes
1539	function eliminateHoles(data, holeIndices, outerNode, dim) {
1540	    var queue = [],
1541	        i, len, start, end, list;
1542
1543	    for (i = 0, len = holeIndices.length; i < len; i++) {
1544	        start = holeIndices[i] * dim;
1545	        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
1546	        list = linkedList(data, start, end, dim, false);
1547	        if (list === list.next) { list.steiner = true; }
1548	        queue.push(getLeftmost(list));
1549	    }
1550
1551	    queue.sort(compareX);
1552
1553	    // process holes from left to right
1554	    for (i = 0; i < queue.length; i++) {
1555	        eliminateHole(queue[i], outerNode);
1556	        outerNode = filterPoints(outerNode, outerNode.next);
1557	    }
1558
1559	    return outerNode;
1560	}
1561
1562	function compareX(a, b) {
1563	    return a.x - b.x;
1564	}
1565
1566	// find a bridge between vertices that connects hole with an outer ring and and link it
1567	function eliminateHole(hole, outerNode) {
1568	    outerNode = findHoleBridge(hole, outerNode);
1569	    if (outerNode) {
1570	        var b = splitPolygon(outerNode, hole);
1571	        filterPoints(b, b.next);
1572	    }
1573	}
1574
1575	// David Eberly's algorithm for finding a bridge between hole and outer polygon
1576	function findHoleBridge(hole, outerNode) {
1577	    var p = outerNode,
1578	        hx = hole.x,
1579	        hy = hole.y,
1580	        qx = -Infinity,
1581	        m;
1582
1583	    // find a segment intersected by a ray from the hole's leftmost point to the left;
1584	    // segment's endpoint with lesser x will be potential connection point
1585	    do {
1586	        if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
1587	            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
1588	            if (x <= hx && x > qx) {
1589	                qx = x;
1590	                if (x === hx) {
1591	                    if (hy === p.y) { return p; }
1592	                    if (hy === p.next.y) { return p.next; }
1593	                }
1594	                m = p.x < p.next.x ? p : p.next;
1595	            }
1596	        }
1597	        p = p.next;
1598	    } while (p !== outerNode);
1599
1600	    if (!m) { return null; }
1601
1602	    if (hx === qx) { return m.prev; } // hole touches outer segment; pick lower endpoint
1603
1604	    // look for points inside the triangle of hole point, segment intersection and endpoint;
1605	    // if there are no points found, we have a valid connection;
1606	    // otherwise choose the point of the minimum angle with the ray as connection point
1607
1608	    var stop = m,
1609	        mx = m.x,
1610	        my = m.y,
1611	        tanMin = Infinity,
1612	        tan;
1613
1614	    p = m.next;
1615
1616	    while (p !== stop) {
1617	        if (hx >= p.x && p.x >= mx && hx !== p.x &&
1618	                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
1619
1620	            tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
1621
1622	            if ((tan < tanMin || (tan === tanMin && p.x > m.x)) && locallyInside(p, hole)) {
1623	                m = p;
1624	                tanMin = tan;
1625	            }
1626	        }
1627
1628	        p = p.next;
1629	    }
1630
1631	    return m;
1632	}
1633
1634	// interlink polygon nodes in z-order
1635	function indexCurve(start, minX, minY, invSize) {
1636	    var p = start;
1637	    do {
1638	        if (p.z === null) { p.z = zOrder(p.x, p.y, minX, minY, invSize); }
1639	        p.prevZ = p.prev;
1640	        p.nextZ = p.next;
1641	        p = p.next;
1642	    } while (p !== start);
1643
1644	    p.prevZ.nextZ = null;
1645	    p.prevZ = null;
1646
1647	    sortLinked(p);
1648	}
1649
1650	// Simon Tatham's linked list merge sort algorithm
1651	// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
1652	function sortLinked(list) {
1653	    var i, p, q, e, tail, numMerges, pSize, qSize,
1654	        inSize = 1;
1655
1656	    do {
1657	        p = list;
1658	        list = null;
1659	        tail = null;
1660	        numMerges = 0;
1661
1662	        while (p) {
1663	            numMerges++;
1664	            q = p;
1665	            pSize = 0;
1666	            for (i = 0; i < inSize; i++) {
1667	                pSize++;
1668	                q = q.nextZ;
1669	                if (!q) { break; }
1670	            }
1671	            qSize = inSize;
1672
1673	            while (pSize > 0 || (qSize > 0 && q)) {
1674
1675	                if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
1676	                    e = p;
1677	                    p = p.nextZ;
1678	                    pSize--;
1679	                } else {
1680	                    e = q;
1681	                    q = q.nextZ;
1682	                    qSize--;
1683	                }
1684
1685	                if (tail) { tail.nextZ = e; }
1686	                else { list = e; }
1687
1688	                e.prevZ = tail;
1689	                tail = e;
1690	            }
1691
1692	            p = q;
1693	        }
1694
1695	        tail.nextZ = null;
1696	        inSize *= 2;
1697
1698	    } while (numMerges > 1);
1699
1700	    return list;
1701	}
1702
1703	// z-order of a point given coords and inverse of the longer side of data bbox
1704	function zOrder(x, y, minX, minY, invSize) {
1705	    // coords are transformed into non-negative 15-bit integer range
1706	    x = 32767 * (x - minX) * invSize;
1707	    y = 32767 * (y - minY) * invSize;
1708
1709	    x = (x | (x << 8)) & 0x00FF00FF;
1710	    x = (x | (x << 4)) & 0x0F0F0F0F;
1711	    x = (x | (x << 2)) & 0x33333333;
1712	    x = (x | (x << 1)) & 0x55555555;
1713
1714	    y = (y | (y << 8)) & 0x00FF00FF;
1715	    y = (y | (y << 4)) & 0x0F0F0F0F;
1716	    y = (y | (y << 2)) & 0x33333333;
1717	    y = (y | (y << 1)) & 0x55555555;
1718
1719	    return x | (y << 1);
1720	}
1721
1722	// find the leftmost node of a polygon ring
1723	function getLeftmost(start) {
1724	    var p = start,
1725	        leftmost = start;
1726	    do {
1727	        if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) { leftmost = p; }
1728	        p = p.next;
1729	    } while (p !== start);
1730
1731	    return leftmost;
1732	}
1733
1734	// check if a point lies within a convex triangle
1735	function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
1736	    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
1737	           (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
1738	           (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
1739	}
1740
1741	// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
1742	function isValidDiagonal(a, b) {
1743	    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) &&
1744	           locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);
1745	}
1746
1747	// signed area of a triangle
1748	function area(p, q, r) {
1749	    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
1750	}
1751
1752	// check if two points are equal
1753	function equals(p1, p2) {
1754	    return p1.x === p2.x && p1.y === p2.y;
1755	}
1756
1757	// check if two segments intersect
1758	function intersects(p1, q1, p2, q2) {
1759	    if ((equals(p1, q1) && equals(p2, q2)) ||
1760	        (equals(p1, q2) && equals(p2, q1))) { return true; }
1761	    return area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 &&
1762	           area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0;
1763	}
1764
1765	// check if a polygon diagonal intersects any polygon segments
1766	function intersectsPolygon(a, b) {
1767	    var p = a;
1768	    do {
1769	        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
1770	                intersects(p, p.next, a, b)) { return true; }
1771	        p = p.next;
1772	    } while (p !== a);
1773
1774	    return false;
1775	}
1776
1777	// check if a polygon diagonal is locally inside the polygon
1778	function locallyInside(a, b) {
1779	    return area(a.prev, a, a.next) < 0 ?
1780	        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
1781	        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
1782	}
1783
1784	// check if the middle point of a polygon diagonal is inside the polygon
1785	function middleInside(a, b) {
1786	    var p = a,
1787	        inside = false,
1788	        px = (a.x + b.x) / 2,
1789	        py = (a.y + b.y) / 2;
1790	    do {
1791	        if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
1792	                (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
1793	            { inside = !inside; }
1794	        p = p.next;
1795	    } while (p !== a);
1796
1797	    return inside;
1798	}
1799
1800	// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
1801	// if one belongs to the outer ring and another to a hole, it merges it into a single ring
1802	function splitPolygon(a, b) {
1803	    var a2 = new Node(a.i, a.x, a.y),
1804	        b2 = new Node(b.i, b.x, b.y),
1805	        an = a.next,
1806	        bp = b.prev;
1807
1808	    a.next = b;
1809	    b.prev = a;
1810
1811	    a2.next = an;
1812	    an.prev = a2;
1813
1814	    b2.next = a2;
1815	    a2.prev = b2;
1816
1817	    bp.next = b2;
1818	    b2.prev = bp;
1819
1820	    return b2;
1821	}
1822
1823	// create a node and optionally link it with previous one (in a circular doubly linked list)
1824	function insertNode(i, x, y, last) {
1825	    var p = new Node(i, x, y);
1826
1827	    if (!last) {
1828	        p.prev = p;
1829	        p.next = p;
1830
1831	    } else {
1832	        p.next = last.next;
1833	        p.prev = last;
1834	        last.next.prev = p;
1835	        last.next = p;
1836	    }
1837	    return p;
1838	}
1839
1840	function removeNode(p) {
1841	    p.next.prev = p.prev;
1842	    p.prev.next = p.next;
1843
1844	    if (p.prevZ) { p.prevZ.nextZ = p.nextZ; }
1845	    if (p.nextZ) { p.nextZ.prevZ = p.prevZ; }
1846	}
1847
1848	function Node(i, x, y) {
1849	    // vertex index in coordinates array
1850	    this.i = i;
1851
1852	    // vertex coordinates
1853	    this.x = x;
1854	    this.y = y;
1855
1856	    // previous and next vertex nodes in a polygon ring
1857	    this.prev = null;
1858	    this.next = null;
1859
1860	    // z-order curve value
1861	    this.z = null;
1862
1863	    // previous and next nodes in z-order
1864	    this.prevZ = null;
1865	    this.nextZ = null;
1866
1867	    // indicates whether this is a steiner point
1868	    this.steiner = false;
1869	}
1870
1871	// return a percentage difference between the polygon area and its triangulation area;
1872	// used to verify correctness of triangulation
1873	earcut.deviation = function (data, holeIndices, dim, triangles) {
1874	    var hasHoles = holeIndices && holeIndices.length;
1875	    var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
1876
1877	    var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
1878	    if (hasHoles) {
1879	        for (var i = 0, len = holeIndices.length; i < len; i++) {
1880	            var start = holeIndices[i] * dim;
1881	            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
1882	            polygonArea -= Math.abs(signedArea(data, start, end, dim));
1883	        }
1884	    }
1885
1886	    var trianglesArea = 0;
1887	    for (i = 0; i < triangles.length; i += 3) {
1888	        var a = triangles[i] * dim;
1889	        var b = triangles[i + 1] * dim;
1890	        var c = triangles[i + 2] * dim;
1891	        trianglesArea += Math.abs(
1892	            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
1893	            (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
1894	    }
1895
1896	    return polygonArea === 0 && trianglesArea === 0 ? 0 :
1897	        Math.abs((trianglesArea - polygonArea) / polygonArea);
1898	};
1899
1900	function signedArea(data, start, end, dim) {
1901	    var sum = 0;
1902	    for (var i = start, j = end - dim; i < end; i += dim) {
1903	        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
1904	        j = i;
1905	    }
1906	    return sum;
1907	}
1908
1909	// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
1910	earcut.flatten = function (data) {
1911	    var dim = data[0][0].length,
1912	        result = {vertices: [], holes: [], dimensions: dim},
1913	        holeIndex = 0;
1914
1915	    for (var i = 0; i < data.length; i++) {
1916	        for (var j = 0; j < data[i].length; j++) {
1917	            for (var d = 0; d < dim; d++) { result.vertices.push(data[i][j][d]); }
1918	        }
1919	        if (i > 0) {
1920	            holeIndex += data[i - 1].length;
1921	            result.holes.push(holeIndex);
1922	        }
1923	    }
1924	    return result;
1925	};
1926	earcut_1.default = default_1;
1927

1928	var punycode = createCommonjsModule(function (module, exports) {
1929	/*! https://mths.be/punycode v1.3.2 by @mathias */
1930	;(function(root) {
1931
1932		/** Detect free variables */
1933		var freeExports = 'object' == 'object' && exports &&
1934			!exports.nodeType && exports;
1935		var freeModule = 'object' == 'object' && module &&
1936			!module.nodeType && module;
1937		var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
1938		if (
1939			freeGlobal.global === freeGlobal ||
1940			freeGlobal.window === freeGlobal ||
1941			freeGlobal.self === freeGlobal
1942		) {
1943			root = freeGlobal;
1944		}
1945
1946		/**
1947		 * The `punycode` object.
1948		 * @name punycode
1949		 * @type Object
1950		 */
1951		var punycode,
1952
1953		/** Highest positive signed 32-bit float value */
1954		maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
1955
1956		/** Bootstring parameters */
1957		base = 36,
1958		tMin = 1,
1959		tMax = 26,
1960		skew = 38,
1961		damp = 700,
1962		initialBias = 72,
1963		initialN = 128, // 0x80
1964		delimiter = '-', // '\x2D'
1965
1966		/** Regular expressions */
1967		regexPunycode = /^xn--/,
1968		regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
1969		regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
1970
1971		/** Error messages */
1972		errors = {
1973			'overflow': 'Overflow: input needs wider integers to process',
1974			'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
1975			'invalid-input': 'Invalid input'
1976		},
1977
1978		/** Convenience shortcuts */
1979		baseMinusTMin = base - tMin,
1980		floor = Math.floor,
1981		stringFromCharCode = String.fromCharCode,
1982
1983		/** Temporary variable */
1984		key;
1985
1986		/*--------------------------------------------------------------------------*/
1987
1988		/**
1989		 * A generic error utility function.
1990		 * @private
1991		 * @param {String} type The error type.
1992		 * @returns {Error} Throws a `RangeError` with the applicable error message.
1993		 */
1994		function error(type) {
1995			throw RangeError(errors[type]);
1996		}
1997
1998		/**
1999		 * A generic `Array#map` utility function.
2000		 * @private
2001		 * @param {Array} array The array to iterate over.
2002		 * @param {Function} callback The function that gets called for every array
2003		 * item.
2004		 * @returns {Array} A new array of values returned by the callback function.
2005		 */
2006		function map(array, fn) {
2007			var length = array.length;
2008			var result = [];
2009			while (length--) {
2010				result[length] = fn(array[length]);
2011			}
2012			return result;
2013		}
2014
2015		/**
2016		 * A simple `Array#map`-like wrapper to work with domain name strings or email
2017		 * addresses.
2018		 * @private
2019		 * @param {String} domain The domain name or email address.
2020		 * @param {Function} callback The function that gets called for every
2021		 * character.
2022		 * @returns {Array} A new string of characters returned by the callback
2023		 * function.
2024		 */
2025		function mapDomain(string, fn) {
2026			var parts = string.split('@');
2027			var result = '';
2028			if (parts.length > 1) {
2029				// In email addresses, only the domain name should be punycoded. Leave
2030				// the local part (i.e. everything up to `@`) intact.
2031				result = parts[0] + '@';
2032				string = parts[1];
2033			}
2034			// Avoid `split(regex)` for IE8 compatibility. See #17.
2035			string = string.replace(regexSeparators, '\x2E');
2036			var labels = string.split('.');
2037			var encoded = map(labels, fn).join('.');
2038			return result + encoded;
2039		}
2040
2041		/**
2042		 * Creates an array containing the numeric code points of each Unicode
2043		 * character in the string. While JavaScript uses UCS-2 internally,
2044		 * this function will convert a pair of surrogate halves (each of which
2045		 * UCS-2 exposes as separate characters) into a single code point,
2046		 * matching UTF-16.
2047		 * @see `punycode.ucs2.encode`
2048		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
2049		 * @memberOf punycode.ucs2
2050		 * @name decode
2051		 * @param {String} string The Unicode input string (UCS-2).
2052		 * @returns {Array} The new array of code points.
2053		 */
2054		function ucs2decode(string) {
2055			var output = [],
2056			    counter = 0,
2057			    length = string.length,
2058			    value,
2059			    extra;
2060			while (counter < length) {
2061				value = string.charCodeAt(counter++);
2062				if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
2063					// high surrogate, and there is a next character
2064					extra = string.charCodeAt(counter++);
2065					if ((extra & 0xFC00) == 0xDC00) { // low surrogate
2066						output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
2067					} else {
2068						// unmatched surrogate; only append this code unit, in case the next
2069						// code unit is the high surrogate of a surrogate pair
2070						output.push(value);
2071						counter--;
2072					}
2073				} else {
2074					output.push(value);
2075				}
2076			}
2077			return output;
2078		}
2079
2080		/**
2081		 * Creates a string based on an array of numeric code points.
2082		 * @see `punycode.ucs2.decode`
2083		 * @memberOf punycode.ucs2
2084		 * @name encode
2085		 * @param {Array} codePoints The array of numeric code points.
2086		 * @returns {String} The new Unicode string (UCS-2).
2087		 */
2088		function ucs2encode(array) {
2089			return map(array, function(value) {
2090				var output = '';
2091				if (value > 0xFFFF) {
2092					value -= 0x10000;
2093					output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
2094					value = 0xDC00 | value & 0x3FF;
2095				}
2096				output += stringFromCharCode(value);
2097				return output;
2098			}).join('');
2099		}
2100
2101		/**
2102		 * Converts a basic code point into a digit/integer.
2103		 * @see `digitToBasic()`
2104		 * @private
2105		 * @param {Number} codePoint The basic numeric code point value.
2106		 * @returns {Number} The numeric value of a basic code point (for use in
2107		 * representing integers) in the range `0` to `base - 1`, or `base` if
2108		 * the code point does not represent a value.
2109		 */
2110		function basicToDigit(codePoint) {
2111			if (codePoint - 48 < 10) {
2112				return codePoint - 22;
2113			}
2114			if (codePoint - 65 < 26) {
2115				return codePoint - 65;
2116			}
2117			if (codePoint - 97 < 26) {
2118				return codePoint - 97;
2119			}
2120			return base;
2121		}
2122
2123		/**
2124		 * Converts a digit/integer into a basic code point.
2125		 * @see `basicToDigit()`
2126		 * @private
2127		 * @param {Number} digit The numeric value of a basic code point.
2128		 * @returns {Number} The basic code point whose value (when used for
2129		 * representing integers) is `digit`, which needs to be in the range
2130		 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
2131		 * used; else, the lowercase form is used. The behavior is undefined
2132		 * if `flag` is non-zero and `digit` has no uppercase form.
2133		 */
2134		function digitToBasic(digit, flag) {
2135			//  0..25 map to ASCII a..z or A..Z
2136			// 26..35 map to ASCII 0..9
2137			return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
2138		}
2139
2140		/**
2141		 * Bias adaptation function as per section 3.4 of RFC 3492.
2142		 * http://tools.ietf.org/html/rfc3492#section-3.4
2143		 * @private
2144		 */
2145		function adapt(delta, numPoints, firstTime) {
2146			var k = 0;
2147			delta = firstTime ? floor(delta / damp) : delta >> 1;
2148			delta += floor(delta / numPoints);
2149			for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
2150				delta = floor(delta / baseMinusTMin);
2151			}
2152			return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
2153		}
2154
2155		/**
2156		 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
2157		 * symbols.
2158		 * @memberOf punycode
2159		 * @param {String} input The Punycode string of ASCII-only symbols.
2160		 * @returns {String} The resulting string of Unicode symbols.
2161		 */
2162		function decode(input) {
2163			// Don't use UCS-2
2164			var output = [],
2165			    inputLength = input.length,
2166			    out,
2167			    i = 0,
2168			    n = initialN,
2169			    bias = initialBias,
2170			    basic,
2171			    j,
2172			    index,
2173			    oldi,
2174			    w,
2175			    k,
2176			    digit,
2177			    t,
2178			    /** Cached calculation results */
2179			    baseMinusT;
2180
2181			// Handle the basic code points: let `basic` be the number of input code
2182			// points before the last delimiter, or `0` if there is none, then copy
2183			// the first basic code points to the output.
2184
2185			basic = input.lastIndexOf(delimiter);
2186			if (basic < 0) {
2187				basic = 0;
2188			}
2189
2190			for (j = 0; j < basic; ++j) {
2191				// if it's not a basic code point
2192				if (input.charCodeAt(j) >= 0x80) {
2193					error('not-basic');
2194				}
2195				output.push(input.charCodeAt(j));
2196			}
2197
2198			// Main decoding loop: start just after the last delimiter if any basic code
2199			// points were copied; start at the beginning otherwise.
2200
2201			for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
2202
2203				// `index` is the index of the next character to be consumed.
2204				// Decode a generalized variable-length integer into `delta`,
2205				// which gets added to `i`. The overflow checking is easier
2206				// if we increase `i` as we go, then subtract off its starting
2207				// value at the end to obtain `delta`.
2208				for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
2209
2210					if (index >= inputLength) {
2211						error('invalid-input');
2212					}
2213
2214					digit = basicToDigit(input.charCodeAt(index++));
2215
2216					if (digit >= base || digit > floor((maxInt - i) / w)) {
2217						error('overflow');
2218					}
2219
2220					i += digit * w;
2221					t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
2222
2223					if (digit < t) {
2224						break;
2225					}
2226
2227					baseMinusT = base - t;
2228					if (w > floor(maxInt / baseMinusT)) {
2229						error('overflow');
2230					}
2231
2232					w *= baseMinusT;
2233
2234				}
2235
2236				out = output.length + 1;
2237				bias = adapt(i - oldi, out, oldi == 0);
2238
2239				// `i` was supposed to wrap around from `out` to `0`,
2240				// incrementing `n` each time, so we'll fix that now:
2241				if (floor(i / out) > maxInt - n) {
2242					error('overflow');
2243				}
2244
2245				n += floor(i / out);
2246				i %= out;
2247
2248				// Insert `n` at position `i` of the output
2249				output.splice(i++, 0, n);
2250
2251			}
2252
2253			return ucs2encode(output);
2254		}
2255
2256		/**
2257		 * Converts a string of Unicode symbols (e.g. a domain name label) to a
2258		 * Punycode string of ASCII-only symbols.
2259		 * @memberOf punycode
2260		 * @param {String} input The string of Unicode symbols.
2261		 * @returns {String} The resulting Punycode string of ASCII-only symbols.
2262		 */
2263		function encode(input) {
2264			var n,
2265			    delta,
2266			    handledCPCount,
2267			    basicLength,
2268			    bias,
2269			    j,
2270			    m,
2271			    q,
2272			    k,
2273			    t,
2274			    currentValue,
2275			    output = [],
2276			    /** `inputLength` will hold the number of code points in `input`. */
2277			    inputLength,
2278			    /** Cached calculation results */
2279			    handledCPCountPlusOne,
2280			    baseMinusT,
2281			    qMinusT;
2282
2283			// Convert the input in UCS-2 to Unicode
2284			input = ucs2decode(input);
2285
2286			// Cache the length
2287			inputLength = input.length;
2288
2289			// Initialize the state
2290			n = initialN;
2291			delta = 0;
2292			bias = initialBias;
2293
2294			// Handle the basic code points
2295			for (j = 0; j < inputLength; ++j) {
2296				currentValue = input[j];
2297				if (currentValue < 0x80) {
2298					output.push(stringFromCharCode(currentValue));
2299				}
2300			}
2301
2302			handledCPCount = basicLength = output.length;
2303
2304			// `handledCPCount` is the number of code points that have been handled;
2305			// `basicLength` is the number of basic code points.
2306
2307			// Finish the basic string - if it is not empty - with a delimiter
2308			if (basicLength) {
2309				output.push(delimiter);
2310			}
2311
2312			// Main encoding loop:
2313			while (handledCPCount < inputLength) {
2314
2315				// All non-basic code points < n have been handled already. Find the next
2316				// larger one:
2317				for (m = maxInt, j = 0; j < inputLength; ++j) {
2318					currentValue = input[j];
2319					if (currentValue >= n && currentValue < m) {
2320						m = currentValue;
2321					}
2322				}
2323
2324				// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
2325				// but guard against overflow
2326				handledCPCountPlusOne = handledCPCount + 1;
2327				if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
2328					error('overflow');
2329				}
2330
2331				delta += (m - n) * handledCPCountPlusOne;
2332				n = m;
2333
2334				for (j = 0; j < inputLength; ++j) {
2335					currentValue = input[j];
2336
2337					if (currentValue < n && ++delta > maxInt) {
2338						error('overflow');
2339					}
2340
2341					if (currentValue == n) {
2342						// Represent delta as a generalized variable-length integer
2343						for (q = delta, k = base; /* no condition */; k += base) {
2344							t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
2345							if (q < t) {
2346								break;
2347							}
2348							qMinusT = q - t;
2349							baseMinusT = base - t;
2350							output.push(
2351								stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
2352							);
2353							q = floor(qMinusT / baseMinusT);
2354						}
2355
2356						output.push(stringFromCharCode(digitToBasic(q, 0)));
2357						bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
2358						delta = 0;
2359						++handledCPCount;
2360					}
2361				}
2362
2363				++delta;
2364				++n;
2365
2366			}
2367			return output.join('');
2368		}
2369
2370		/**
2371		 * Converts a Punycode string representing a domain name or an email address
2372		 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
2373		 * it doesn't matter if you call it on a string that has already been
2374		 * converted to Unicode.
2375		 * @memberOf punycode
2376		 * @param {String} input The Punycoded domain name or email address to
2377		 * convert to Unicode.
2378		 * @returns {String} The Unicode representation of the given Punycode
2379		 * string.
2380		 */
2381		function toUnicode(input) {
2382			return mapDomain(input, function(string) {
2383				return regexPunycode.test(string)
2384					? decode(string.slice(4).toLowerCase())
2385					: string;
2386			});
2387		}
2388
2389		/**
2390		 * Converts a Unicode string representing a domain name or an email address to
2391		 * Punycode. Only the non-ASCII parts of the domain name will be converted,
2392		 * i.e. it doesn't matter if you call it with a domain that's already in
2393		 * ASCII.
2394		 * @memberOf punycode
2395		 * @param {String} input The domain name or email address to convert, as a
2396		 * Unicode string.
2397		 * @returns {String} The Punycode representation of the given domain name or
2398		 * email address.
2399		 */
2400		function toASCII(input) {
2401			return mapDomain(input, function(string) {
2402				return regexNonASCII.test(string)
2403					? 'xn--' + encode(string)
2404					: string;
2405			});
2406		}
2407
2408		/*--------------------------------------------------------------------------*/
2409
2410		/** Define the public API */
2411		punycode = {
2412			/**
2413			 * A string representing the current Punycode.js version number.
2414			 * @memberOf punycode
2415			 * @type String
2416			 */
2417			'version': '1.3.2',
2418			/**
2419			 * An object of methods to convert from JavaScript's internal character
2420			 * representation (UCS-2) to Unicode code points, and back.
2421			 * @see <https://mathiasbynens.be/notes/javascript-encoding>
2422			 * @memberOf punycode
2423			 * @type Object
2424			 */
2425			'ucs2': {
2426				'decode': ucs2decode,
2427				'encode': ucs2encode
2428			},
2429			'decode': decode,
2430			'encode': encode,
2431			'toASCII': toASCII,
2432			'toUnicode': toUnicode
2433		};
2434
2435		/** Expose `punycode` */
2436		// Some AMD build optimizers, like r.js, check for specific condition patterns
2437		// like the following:
2438		if (
2439			typeof undefined == 'function' &&
2440			typeof undefined.amd == 'object' &&
2441			undefined.amd
2442		) {
2443			undefined('punycode', function() {
2444				return punycode;
2445			});
2446		} else if (freeExports && freeModule) {
2447			if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
2448				freeModule.exports = punycode;
2449			} else { // in Narwhal or RingoJS v0.7.0-
2450				for (key in punycode) {
2451					punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
2452				}
2453			}
2454		} else { // in Rhino or a web browser
2455			root.punycode = punycode;
2456		}
2457
2458	}(commonjsGlobal));
2459	});
2460
2461	'use strict';
2462
2463	var util = {
2464	  isString: function(arg) {
2465	    return typeof(arg) === 'string';
2466	  },
2467	  isObject: function(arg) {
2468	    return typeof(arg) === 'object' && arg !== null;
2469	  },
2470	  isNull: function(arg) {
2471	    return arg === null;
2472	  },
2473	  isNullOrUndefined: function(arg) {
2474	    return arg == null;
2475	  }
2476	};
2477	var util_1 = util.isString;
2478	var util_2 = util.isObject;
2479	var util_3 = util.isNull;
2480	var util_4 = util.isNullOrUndefined;
2481
2482	// Copyright Joyent, Inc. and other Node contributors.
2483	//
2484	// Permission is hereby granted, free of charge, to any person obtaining a
2485	// copy of this software and associated documentation files (the
2486	// "Software"), to deal in the Software without restriction, including
2487	// without limitation the rights to use, copy, modify, merge, publish,
2488	// distribute, sublicense, and/or sell copies of the Software, and to permit
2489	// persons to whom the Software is furnished to do so, subject to the
2490	// following conditions:
2491	//
2492	// The above copyright notice and this permission notice shall be included
2493	// in all copies or substantial portions of the Software.
2494	//
2495	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2496	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2497	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2498	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2499	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2500	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2501	// USE OR OTHER DEALINGS IN THE SOFTWARE.
2502
2503	'use strict';
2504
2505	// If obj.hasOwnProperty has been overridden, then calling
2506	// obj.hasOwnProperty(prop) will break.
2507	// See: https://github.com/joyent/node/issues/1707
2508	function hasOwnProperty$1(obj, prop) {
2509	  return Object.prototype.hasOwnProperty.call(obj, prop);
2510	}
2511
2512	var decode = function(qs, sep, eq, options) {
2513	  sep = sep || '&';
2514	  eq = eq || '=';
2515	  var obj = {};
2516
2517	  if (typeof qs !== 'string' || qs.length === 0) {
2518	    return obj;
2519	  }
2520
2521	  var regexp = /\+/g;
2522	  qs = qs.split(sep);
2523
2524	  var maxKeys = 1000;
2525	  if (options && typeof options.maxKeys === 'number') {
2526	    maxKeys = options.maxKeys;
2527	  }
2528
2529	  var len = qs.length;
2530	  // maxKeys <= 0 means that we should not limit keys count
2531	  if (maxKeys > 0 && len > maxKeys) {
2532	    len = maxKeys;
2533	  }
2534
2535	  for (var i = 0; i < len; ++i) {
2536	    var x = qs[i].replace(regexp, '%20'),
2537	        idx = x.indexOf(eq),
2538	        kstr, vstr, k, v;
2539
2540	    if (idx >= 0) {
2541	      kstr = x.substr(0, idx);
2542	      vstr = x.substr(idx + 1);
2543	    } else {
2544	      kstr = x;
2545	      vstr = '';
2546	    }
2547
2548	    k = decodeURIComponent(kstr);
2549	    v = decodeURIComponent(vstr);
2550
2551	    if (!hasOwnProperty$1(obj, k)) {
2552	      obj[k] = v;
2553	    } else if (Array.isArray(obj[k])) {
2554	      obj[k].push(v);
2555	    } else {
2556	      obj[k] = [obj[k], v];
2557	    }
2558	  }
2559
2560	  return obj;
2561	};
2562
2563	// Copyright Joyent, Inc. and other Node contributors.
2564	//
2565	// Permission is hereby granted, free of charge, to any person obtaining a
2566	// copy of this software and associated documentation files (the
2567	// "Software"), to deal in the Software without restriction, including
2568	// without limitation the rights to use, copy, modify, merge, publish,
2569	// distribute, sublicense, and/or sell copies of the Software, and to permit
2570	// persons to whom the Software is furnished to do so, subject to the
2571	// following conditions:
2572	//
2573	// The above copyright notice and this permission notice shall be included
2574	// in all copies or substantial portions of the Software.
2575	//
2576	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2577	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2578	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2579	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2580	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2581	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2582	// USE OR OTHER DEALINGS IN THE SOFTWARE.
2583
2584	'use strict';
2585
2586	var stringifyPrimitive = function(v) {
2587	  switch (typeof v) {
2588	    case 'string':
2589	      return v;
2590
2591	    case 'boolean':
2592	      return v ? 'true' : 'false';
2593
2594	    case 'number':
2595	      return isFinite(v) ? v : '';
2596
2597	    default:
2598	      return '';
2599	  }
2600	};
2601
2602	var encode = function(obj, sep, eq, name) {
2603	  sep = sep || '&';
2604	  eq = eq || '=';
2605	  if (obj === null) {
2606	    obj = undefined;
2607	  }
2608
2609	  if (typeof obj === 'object') {
2610	    return Object.keys(obj).map(function(k) {
2611	      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
2612	      if (Array.isArray(obj[k])) {
2613	        return obj[k].map(function(v) {
2614	          return ks + encodeURIComponent(stringifyPrimitive(v));
2615	        }).join(sep);
2616	      } else {
2617	        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
2618	      }
2619	    }).join(sep);
2620
2621	  }
2622
2623	  if (!name) { return ''; }
2624	  return encodeURIComponent(stringifyPrimitive(name)) + eq +
2625	         encodeURIComponent(stringifyPrimitive(obj));
2626	};
2627
2628	var querystring = createCommonjsModule(function (module, exports) {
2629	'use strict';
2630
2631	exports.decode = exports.parse = decode;
2632	exports.encode = exports.stringify = encode;
2633	});
2634	var querystring_1 = querystring.decode;
2635	var querystring_2 = querystring.parse;
2636	var querystring_3 = querystring.encode;
2637	var querystring_4 = querystring.stringify;
2638
2639	// Copyright Joyent, Inc. and other Node contributors.
2640	//
2641	// Permission is hereby granted, free of charge, to any person obtaining a
2642	// copy of this software and associated documentation files (the
2643	// "Software"), to deal in the Software without restriction, including
2644	// without limitation the rights to use, copy, modify, merge, publish,
2645	// distribute, sublicense, and/or sell copies of the Software, and to permit
2646	// persons to whom the Software is furnished to do so, subject to the
2647	// following conditions:
2648	//
2649	// The above copyright notice and this permission notice shall be included
2650	// in all copies or substantial portions of the Software.
2651	//
2652	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2653	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2654	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
2655	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
2656	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
2657	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2658	// USE OR OTHER DEALINGS IN THE SOFTWARE.
2659
2660	'use strict';
2661
2662
2663
2664
2665	var parse = urlParse;
2666	var resolve = urlResolve;
2667	var resolveObject = urlResolveObject;
2668	var format = urlFormat;
2669
2670	var Url_1 = Url;
2671
2672	function Url() {
2673	  this.protocol = null;
2674	  this.slashes = null;
2675	  this.auth = null;
2676	  this.host = null;
2677	  this.port = null;
2678	  this.hostname = null;
2679	  this.hash = null;
2680	  this.search = null;
2681	  this.query = null;
2682	  this.pathname = null;
2683	  this.path = null;
2684	  this.href = null;
2685	}
2686
2687	// Reference: RFC 3986, RFC 1808, RFC 2396
2688
2689	// define these here so at least they only have to be
2690	// compiled once on the first module load.
2691	var protocolPattern = /^([a-z0-9.+-]+:)/i,
2692	    portPattern = /:[0-9]*$/,
2693
2694	    // Special case for a simple path URL
2695	    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
2696
2697	    // RFC 2396: characters reserved for delimiting URLs.
2698	    // We actually just auto-escape these.
2699	    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
2700
2701	    // RFC 2396: characters not allowed for various reasons.
2702	    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
2703
2704	    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
2705	    autoEscape = ['\''].concat(unwise),
2706	    // Characters that are never ever allowed in a hostname.
2707	    // Note that any invalid chars are also handled, but these
2708	    // are the ones that are *expected* to be seen, so we fast-path
2709	    // them.
2710	    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
2711	    hostEndingChars = ['/', '?', '#'],
2712	    hostnameMaxLen = 255,
2713	    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
2714	    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
2715	    // protocols that can allow "unsafe" and "unwise" chars.
2716	    unsafeProtocol = {
2717	      'javascript': true,
2718	      'javascript:': true
2719	    },
2720	    // protocols that never have a hostname.
2721	    hostlessProtocol = {
2722	      'javascript': true,
2723	      'javascript:': true
2724	    },
2725	    // protocols that always contain a // bit.
2726	    slashedProtocol = {
2727	      'http': true,
2728	      'https': true,
2729	      'ftp': true,
2730	      'gopher': true,
2731	      'file': true,
2732	      'http:': true,
2733	      'https:': true,
2734	      'ftp:': true,
2735	      'gopher:': true,
2736	      'file:': true
2737	    };
2738
2739	function urlParse(url, parseQueryString, slashesDenoteHost) {
2740	  if (url && util.isObject(url) && url instanceof Url) { return url; }
2741
2742	  var u = new Url;
2743	  u.parse(url, parseQueryString, slashesDenoteHost);
2744	  return u;
2745	}
2746
2747	Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
2748	  if (!util.isString(url)) {
2749	    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
2750	  }
2751
2752	  // Copy chrome, IE, opera backslash-handling behavior.
2753	  // Back slashes before the query string get converted to forward slashes
2754	  // See: https://code.google.com/p/chromium/issues/detail?id=25916
2755	  var queryIndex = url.indexOf('?'),
2756	      splitter =
2757	          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
2758	      uSplit = url.split(splitter),
2759	      slashRegex = /\\/g;
2760	  uSplit[0] = uSplit[0].replace(slashRegex, '/');
2761	  url = uSplit.join(splitter);
2762
2763	  var rest = url;
2764
2765	  // trim before proceeding.
2766	  // This is to support parse stuff like "  http://foo.com  \n"
2767	  rest = rest.trim();
2768
2769	  if (!slashesDenoteHost && url.split('#').length === 1) {
2770	    // Try fast path regexp
2771	    var simplePath = simplePathPattern.exec(rest);
2772	    if (simplePath) {
2773	      this.path = rest;
2774	      this.href = rest;
2775	      this.pathname = simplePath[1];
2776	      if (simplePath[2]) {
2777	        this.search = simplePath[2];
2778	        if (parseQueryString) {
2779	          this.query = querystring.parse(this.search.substr(1));
2780	        } else {
2781	          this.query = this.search.substr(1);
2782	        }
2783	      } else if (parseQueryString) {
2784	        this.search = '';
2785	        this.query = {};
2786	      }
2787	      return this;
2788	    }
2789	  }
2790
2791	  var proto = protocolPattern.exec(rest);
2792	  if (proto) {
2793	    proto = proto[0];
2794	    var lowerProto = proto.toLowerCase();
2795	    this.protocol = lowerProto;
2796	    rest = rest.substr(proto.length);
2797	  }
2798
2799	  // figure out if it's got a host
2800	  // user@server is *always* interpreted as a hostname, and url
2801	  // resolution will treat //foo/bar as host=foo,path=bar because that's
2802	  // how the browser resolves relative URLs.
2803	  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
2804	    var slashes = rest.substr(0, 2) === '//';
2805	    if (slashes && !(proto && hostlessProtocol[proto])) {
2806	      rest = rest.substr(2);
2807	      this.slashes = true;
2808	    }
2809	  }
2810
2811	  if (!hostlessProtocol[proto] &&
2812	      (slashes || (proto && !slashedProtocol[proto]))) {
2813
2814	    // there's a hostname.
2815	    // the first instance of /, ?, ;, or # ends the host.
2816	    //
2817	    // If there is an @ in the hostname, then non-host chars *are* allowed
2818	    // to the left of the last @ sign, unless some host-ending character
2819	    // comes *before* the @-sign.
2820	    // URLs are obnoxious.
2821	    //
2822	    // ex:
2823	    // http://a@b@c/ => user:a@b host:c
2824	    // http://a@b?@c => user:a host:c path:/?@c
2825
2826	    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
2827	    // Review our test case against browsers more comprehensively.
2828
2829	    // find the first instance of any hostEndingChars
2830	    var hostEnd = -1;
2831	    for (var i = 0; i < hostEndingChars.length; i++) {
2832	      var hec = rest.indexOf(hostEndingChars[i]);
2833	      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
2834	        { hostEnd = hec; }
2835	    }
2836
2837	    // at this point, either we have an explicit point where the
2838	    // auth portion cannot go past, or the last @ char is the decider.
2839	    var auth, atSign;
2840	    if (hostEnd === -1) {
2841	      // atSign can be anywhere.
2842	      atSign = rest.lastIndexOf('@');
2843	    } else {
2844	      // atSign must be in auth portion.
2845	      // http://a@b/c@d => host:b auth:a path:/c@d
2846	      atSign = rest.lastIndexOf('@', hostEnd);
2847	    }
2848
2849	    // Now we have a portion which is definitely the auth.
2850	    // Pull that off.
2851	    if (atSign !== -1) {
2852	      auth = rest.slice(0, atSign);
2853	      rest = rest.slice(atSign + 1);
2854	      this.auth = decodeURIComponent(auth);
2855	    }
2856
2857	    // the host is the remaining to the left of the first non-host char
2858	    hostEnd = -1;
2859	    for (var i = 0; i < nonHostChars.length; i++) {
2860	      var hec = rest.indexOf(nonHostChars[i]);
2861	      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
2862	        { hostEnd = hec; }
2863	    }
2864	    // if we still have not hit it, then the entire thing is a host.
2865	    if (hostEnd === -1)
2866	      { hostEnd = rest.length; }
2867
2868	    this.host = rest.slice(0, hostEnd);
2869	    rest = rest.slice(hostEnd);
2870
2871	    // pull out port.
2872	    this.parseHost();
2873
2874	    // we've indicated that there is a hostname,
2875	    // so even if it's empty, it has to be present.
2876	    this.hostname = this.hostname || '';
2877
2878	    // if hostname begins with [ and ends with ]
2879	    // assume that it's an IPv6 address.
2880	    var ipv6Hostname = this.hostname[0] === '[' &&
2881	        this.hostname[this.hostname.length - 1] === ']';
2882
2883	    // validate a little.
2884	    if (!ipv6Hostname) {
2885	      var hostparts = this.hostname.split(/\./);
2886	      for (var i = 0, l = hostparts.length; i < l; i++) {
2887	        var part = hostparts[i];
2888	        if (!part) { continue; }
2889	        if (!part.match(hostnamePartPattern)) {
2890	          var newpart = '';
2891	          for (var j = 0, k = part.length; j < k; j++) {
2892	            if (part.charCodeAt(j) > 127) {
2893	              // we replace non-ASCII char with a temporary placeholder
2894	              // we need this to make sure size of hostname is not
2895	              // broken by replacing non-ASCII by nothing
2896	              newpart += 'x';
2897	            } else {
2898	              newpart += part[j];
2899	            }
2900	          }
2901	          // we test again with ASCII char only
2902	          if (!newpart.match(hostnamePartPattern)) {
2903	            var validParts = hostparts.slice(0, i);
2904	            var notHost = hostparts.slice(i + 1);
2905	            var bit = part.match(hostnamePartStart);
2906	            if (bit) {
2907	              validParts.push(bit[1]);
2908	              notHost.unshift(bit[2]);
2909	            }
2910	            if (notHost.length) {
2911	              rest = '/' + notHost.join('.') + rest;
2912	            }
2913	            this.hostname = validParts.join('.');
2914	            break;
2915	          }
2916	        }
2917	      }
2918	    }
2919
2920	    if (this.hostname.length > hostnameMaxLen) {
2921	      this.hostname = '';
2922	    } else {
2923	      // hostnames are always lower case.
2924	      this.hostname = this.hostname.toLowerCase();
2925	    }
2926
2927	    if (!ipv6Hostname) {
2928	      // IDNA Support: Returns a punycoded representation of "domain".
2929	      // It only converts parts of the domain name that
2930	      // have non-ASCII characters, i.e. it doesn't matter if
2931	      // you call it with a domain that already is ASCII-only.
2932	      this.hostname = punycode.toASCII(this.hostname);
2933	    }
2934
2935	    var p = this.port ? ':' + this.port : '';
2936	    var h = this.hostname || '';
2937	    this.host = h + p;
2938	    this.href += this.host;
2939
2940	    // strip [ and ] from the hostname
2941	    // the host field still retains them, though
2942	    if (ipv6Hostname) {
2943	      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
2944	      if (rest[0] !== '/') {
2945	        rest = '/' + rest;
2946	      }
2947	    }
2948	  }
2949
2950	  // now rest is set to the post-host stuff.
2951	  // chop off any delim chars.
2952	  if (!unsafeProtocol[lowerProto]) {
2953
2954	    // First, make 100% sure that any "autoEscape" chars get
2955	    // escaped, even if encodeURIComponent doesn't think they
2956	    // need to be.
2957	    for (var i = 0, l = autoEscape.length; i < l; i++) {
2958	      var ae = autoEscape[i];
2959	      if (rest.indexOf(ae) === -1)
2960	        { continue; }
2961	      var esc = encodeURIComponent(ae);
2962	      if (esc === ae) {
2963	        esc = escape(ae);
2964	      }
2965	      rest = rest.split(ae).join(esc);
2966	    }
2967	  }
2968
2969
2970	  // chop off from the tail first.
2971	  var hash = rest.indexOf('#');
2972	  if (hash !== -1) {
2973	    // got a fragment string.
2974	    this.hash = rest.substr(hash);
2975	    rest = rest.slice(0, hash);
2976	  }
2977	  var qm = rest.indexOf('?');
2978	  if (qm !== -1) {
2979	    this.search = rest.substr(qm);
2980	    this.query = rest.substr(qm + 1);
2981	    if (parseQueryString) {
2982	      this.query = querystring.parse(this.query);
2983	    }
2984	    rest = rest.slice(0, qm);
2985	  } else if (parseQueryString) {
2986	    // no query string, but parseQueryString still requested
2987	    this.search = '';
2988	    this.query = {};
2989	  }
2990	  if (rest) { this.pathname = rest; }
2991	  if (slashedProtocol[lowerProto] &&
2992	      this.hostname && !this.pathname) {
2993	    this.pathname = '/';
2994	  }
2995
2996	  //to support http.request
2997	  if (this.pathname || this.search) {
2998	    var p = this.pathname || '';
2999	    var s = this.search || '';
3000	    this.path = p + s;
3001	  }
3002
3003	  // finally, reconstruct the href based on what has been validated.
3004	  this.href = this.format();
3005	  return this;
3006	};
3007
3008	// format a parsed object into a url string
3009	function urlFormat(obj) {
3010	  // ensure it's an object, and not a string url.
3011	  // If it's an obj, this is a no-op.
3012	  // this way, you can call url_format() on strings
3013	  // to clean up potentially wonky urls.
3014	  if (util.isString(obj)) { obj = urlParse(obj); }
3015	  if (!(obj instanceof Url)) { return Url.prototype.format.call(obj); }
3016	  return obj.format();
3017	}
3018
3019	Url.prototype.format = function() {
3020	  var auth = this.auth || '';
3021	  if (auth) {
3022	    auth = encodeURIComponent(auth);
3023	    auth = auth.replace(/%3A/i, ':');
3024	    auth += '@';
3025	  }
3026
3027	  var protocol = this.protocol || '',
3028	      pathname = this.pathname || '',
3029	      hash = this.hash || '',
3030	      host = false,
3031	      query = '';
3032
3033	  if (this.host) {
3034	    host = auth + this.host;
3035	  } else if (this.hostname) {
3036	    host = auth + (this.hostname.indexOf(':') === -1 ?
3037	        this.hostname :
3038	        '[' + this.hostname + ']');
3039	    if (this.port) {
3040	      host += ':' + this.port;
3041	    }
3042	  }
3043
3044	  if (this.query &&
3045	      util.isObject(this.query) &&
3046	      Object.keys(this.query).length) {
3047	    query = querystring.stringify(this.query);
3048	  }
3049
3050	  var search = this.search || (query && ('?' + query)) || '';
3051
3052	  if (protocol && protocol.substr(-1) !== ':') { protocol += ':'; }
3053
3054	  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
3055	  // unless they had them to begin with.
3056	  if (this.slashes ||
3057	      (!protocol || slashedProtocol[protocol]) && host !== false) {
3058	    host = '//' + (host || '');
3059	    if (pathname && pathname.charAt(0) !== '/') { pathname = '/' + pathname; }
3060	  } else if (!host) {
3061	    host = '';
3062	  }
3063
3064	  if (hash && hash.charAt(0) !== '#') { hash = '#' + hash; }
3065	  if (search && search.charAt(0) !== '?') { search = '?' + search; }
3066
3067	  pathname = pathname.replace(/[?#]/g, function(match) {
3068	    return encodeURIComponent(match);
3069	  });
3070	  search = search.replace('#', '%23');
3071
3072	  return protocol + host + pathname + search + hash;
3073	};
3074
3075	function urlResolve(source, relative) {
3076	  return urlParse(source, false, true).resolve(relative);
3077	}
3078
3079	Url.prototype.resolve = function(relative) {
3080	  return this.resolveObject(urlParse(relative, false, true)).format();
3081	};
3082
3083	function urlResolveObject(source, relative) {
3084	  if (!source) { return relative; }
3085	  return urlParse(source, false, true).resolveObject(relative);
3086	}
3087
3088	Url.prototype.resolveObject = function(relative) {
3089	  if (util.isString(relative)) {
3090	    var rel = new Url();
3091	    rel.parse(relative, false, true);
3092	    relative = rel;
3093	  }
3094
3095	  var result = new Url();
3096	  var tkeys = Object.keys(this);
3097	  for (var tk = 0; tk < tkeys.length; tk++) {
3098	    var tkey = tkeys[tk];
3099	    result[tkey] = this[tkey];
3100	  }
3101
3102	  // hash is always overridden, no matter what.
3103	  // even href="" will remove it.
3104	  result.hash = relative.hash;
3105
3106	  // if the relative url is empty, then there's nothing left to do here.
3107	  if (relative.href === '') {
3108	    result.href = result.format();
3109	    return result;
3110	  }
3111
3112	  // hrefs like //foo/bar always cut to the protocol.
3113	  if (relative.slashes && !relative.protocol) {
3114	    // take everything except the protocol from relative
3115	    var rkeys = Object.keys(relative);
3116	    for (var rk = 0; rk < rkeys.length; rk++) {
3117	      var rkey = rkeys[rk];
3118	      if (rkey !== 'protocol')
3119	        { result[rkey] = relative[rkey]; }
3120	    }
3121
3122	    //urlParse appends trailing / to urls like http://www.example.com
3123	    if (slashedProtocol[result.protocol] &&
3124	        result.hostname && !result.pathname) {
3125	      result.path = result.pathname = '/';
3126	    }
3127
3128	    result.href = result.format();
3129	    return result;
3130	  }
3131
3132	  if (relative.protocol && relative.protocol !== result.protocol) {
3133	    // if it's a known url protocol, then changing
3134	    // the protocol does weird things
3135	    // first, if it's not file:, then we MUST have a host,
3136	    // and if there was a path
3137	    // to begin with, then we MUST have a path.
3138	    // if it is file:, then the host is dropped,
3139	    // because that's known to be hostless.
3140	    // anything else is assumed to be absolute.
3141	    if (!slashedProtocol[relative.protocol]) {
3142	      var keys = Object.keys(relative);
3143	      for (var v = 0; v < keys.length; v++) {
3144	        var k = keys[v];
3145	        result[k] = relative[k];
3146	      }
3147	      result.href = result.format();
3148	      return result;
3149	    }
3150
3151	    result.protocol = relative.protocol;
3152	    if (!relative.host && !hostlessProtocol[relative.protocol]) {
3153	      var relPath = (relative.pathname || '').split('/');
3154	      while (relPath.length && !(relative.host = relPath.shift())){ ; }
3155	      if (!relative.host) { relative.host = ''; }
3156	      if (!relative.hostname) { relative.hostname = ''; }
3157	      if (relPath[0] !== '') { relPath.unshift(''); }
3158	      if (relPath.length < 2) { relPath.unshift(''); }
3159	      result.pathname = relPath.join('/');
3160	    } else {
3161	      result.pathname = relative.pathname;
3162	    }
3163	    result.search = relative.search;
3164	    result.query = relative.query;
3165	    result.host = relative.host || '';
3166	    result.auth = relative.auth;
3167	    result.hostname = relative.hostname || relative.host;
3168	    result.port = relative.port;
3169	    // to support http.request
3170	    if (result.pathname || result.search) {
3171	      var p = result.pathname || '';
3172	      var s = result.search || '';
3173	      result.path = p + s;
3174	    }
3175	    result.slashes = result.slashes || relative.slashes;
3176	    result.href = result.format();
3177	    return result;
3178	  }
3179
3180	  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
3181	      isRelAbs = (
3182	          relative.host ||
3183	          relative.pathname && relative.pathname.charAt(0) === '/'
3184	      ),
3185	      mustEndAbs = (isRelAbs || isSourceAbs ||
3186	                    (result.host && relative.pathname)),
3187	      removeAllDots = mustEndAbs,
3188	      srcPath = result.pathname && result.pathname.split('/') || [],
3189	      relPath = relative.pathname && relative.pathname.split('/') || [],
3190	      psychotic = result.protocol && !slashedProtocol[result.protocol];
3191
3192	  // if the url is a non-slashed url, then relative
3193	  // links like ../.. should be able
3194	  // to crawl up to the hostname, as well.  This is strange.
3195	  // result.protocol has already been set by now.
3196	  // Later on, put the first path part into the host field.
3197	  if (psychotic) {
3198	    result.hostname = '';
3199	    result.port = null;
3200	    if (result.host) {
3201	      if (srcPath[0] === '') { srcPath[0] = result.host; }
3202	      else { srcPath.unshift(result.host); }
3203	    }
3204	    result.host = '';
3205	    if (relative.protocol) {
3206	      relative.hostname = null;
3207	      relative.port = null;
3208	      if (relative.host) {
3209	        if (relPath[0] === '') { relPath[0] = relative.host; }
3210	        else { relPath.unshift(relative.host); }
3211	      }
3212	      relative.host = null;
3213	    }
3214	    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
3215	  }
3216
3217	  if (isRelAbs) {
3218	    // it's absolute.
3219	    result.host = (relative.host || relative.host === '') ?
3220	                  relative.host : result.host;
3221	    result.hostname = (relative.hostname || relative.hostname === '') ?
3222	                      relative.hostname : result.hostname;
3223	    result.search = relative.search;
3224	    result.query = relative.query;
3225	    srcPath = relPath;
3226	    // fall through to the dot-handling below.
3227	  } else if (relPath.length) {
3228	    // it's relative
3229	    // throw away the existing file, and take the new path instead.
3230	    if (!srcPath) { srcPath = []; }
3231	    srcPath.pop();
3232	    srcPath = srcPath.concat(relPath);
3233	    result.search = relative.search;
3234	    result.query = relative.query;
3235	  } else if (!util.isNullOrUndefined(relative.search)) {
3236	    // just pull out the search.
3237	    // like href='?foo'.
3238	    // Put this after the other two cases because it simplifies the booleans
3239	    if (psychotic) {
3240	      result.hostname = result.host = srcPath.shift();
3241	      //occationaly the auth can get stuck only in host
3242	      //this especially happens in cases like
3243	      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
3244	      var authInHost = result.host && result.host.indexOf('@') > 0 ?
3245	                       result.host.split('@') : false;
3246	      if (authInHost) {
3247	        result.auth = authInHost.shift();
3248	        result.host = result.hostname = authInHost.shift();
3249	      }
3250	    }
3251	    result.search = relative.search;
3252	    result.query = relative.query;
3253	    //to support http.request
3254	    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
3255	      result.path = (result.pathname ? result.pathname : '') +
3256	                    (result.search ? result.search : '');
3257	    }
3258	    result.href = result.format();
3259	    return result;
3260	  }
3261
3262	  if (!srcPath.length) {
3263	    // no path at all.  easy.
3264	    // we've already handled the other stuff above.
3265	    result.pathname = null;
3266	    //to support http.request
3267	    if (result.search) {
3268	      result.path = '/' + result.search;
3269	    } else {
3270	      result.path = null;
3271	    }
3272	    result.href = result.format();
3273	    return result;
3274	  }
3275
3276	  // if a url ENDs in . or .., then it must get a trailing slash.
3277	  // however, if it ends in anything else non-slashy,
3278	  // then it must NOT get a trailing slash.
3279	  var last = srcPath.slice(-1)[0];
3280	  var hasTrailingSlash = (
3281	      (result.host || relative.host || srcPath.length > 1) &&
3282	      (last === '.' || last === '..') || last === '');
3283
3284	  // strip single dots, resolve double dots to parent dir
3285	  // if the path tries to go above the root, `up` ends up > 0
3286	  var up = 0;
3287	  for (var i = srcPath.length; i >= 0; i--) {
3288	    last = srcPath[i];
3289	    if (last === '.') {
3290	      srcPath.splice(i, 1);
3291	    } else if (last === '..') {
3292	      srcPath.splice(i, 1);
3293	      up++;
3294	    } else if (up) {
3295	      srcPath.splice(i, 1);
3296	      up--;
3297	    }
3298	  }
3299
3300	  // if the path is allowed to go above the root, restore leading ..s
3301	  if (!mustEndAbs && !removeAllDots) {
3302	    for (; up--; up) {
3303	      srcPath.unshift('..');
3304	    }
3305	  }
3306
3307	  if (mustEndAbs && srcPath[0] !== '' &&
3308	      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
3309	    srcPath.unshift('');
3310	  }
3311
3312	  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
3313	    srcPath.push('');
3314	  }
3315
3316	  var isAbsolute = srcPath[0] === '' ||
3317	      (srcPath[0] && srcPath[0].charAt(0) === '/');
3318
3319	  // put the host back
3320	  if (psychotic) {
3321	    result.hostname = result.host = isAbsolute ? '' :
3322	                                    srcPath.length ? srcPath.shift() : '';
3323	    //occationaly the auth can get stuck only in host
3324	    //this especially happens in cases like
3325	    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
3326	    var authInHost = result.host && result.host.indexOf('@') > 0 ?
3327	                     result.host.split('@') : false;
3328	    if (authInHost) {
3329	      result.auth = authInHost.shift();
3330	      result.host = result.hostname = authInHost.shift();
3331	    }
3332	  }
3333
3334	  mustEndAbs = mustEndAbs || (result.host && srcPath.length);
3335
3336	  if (mustEndAbs && !isAbsolute) {
3337	    srcPath.unshift('');
3338	  }
3339
3340	  if (!srcPath.length) {
3341	    result.pathname = null;
3342	    result.path = null;
3343	  } else {
3344	    result.pathname = srcPath.join('/');
3345	  }
3346
3347	  //to support request.http
3348	  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
3349	    result.path = (result.pathname ? result.pathname : '') +
3350	                  (result.search ? result.search : '');
3351	  }
3352	  result.auth = relative.auth || result.auth;
3353	  result.slashes = result.slashes || relative.slashes;
3354	  result.href = result.format();
3355	  return result;
3356	};
3357
3358	Url.prototype.parseHost = function() {
3359	  var host = this.host;
3360	  var port = portPattern.exec(host);
3361	  if (port) {
3362	    port = port[0];
3363	    if (port !== ':') {
3364	      this.port = port.substr(1);
3365	    }
3366	    host = host.substr(0, host.length - port.length);
3367	  }
3368	  if (host) { this.hostname = host; }
3369	};
3370
3371	var url = {
3372		parse: parse,
3373		resolve: resolve,
3374		resolveObject: resolveObject,
3375		format: format,
3376		Url: Url_1
3377	};
3378
3379	/*!
3380	 * @pixi/constants - v5.0.0-rc.3
3381	 * Compiled Fri, 22 Mar 2019 16:39:26 UTC
3382	 *
3383	 * @pixi/constants is licensed under the MIT License.
3384	 * http://www.opensource.org/licenses/mit-license
3385	 */
3386	/**
3387	 * Different types of environments for WebGL.
3388	 *
3389	 * @static
3390	 * @memberof PIXI
3391	 * @name ENV
3392	 * @enum {number}
3393	 * @property {number} WEBGL_LEGACY - Used for older v1 WebGL devices. PixiJS will aim to ensure compatibility
3394	 *  with older / less advanced devices. If you experience unexplained flickering prefer this environment.
3395	 * @property {number} WEBGL - Version 1 of WebGL
3396	 * @property {number} WEBGL2 - Version 2 of WebGL
3397	 */
3398	var ENV = {
3399	    WEBGL_LEGACY: 0,
3400	    WEBGL: 1,
3401	    WEBGL2: 2,
3402	};
3403
3404	/**
3405	 * Constant to identify the Renderer Type.
3406	 *
3407	 * @static
3408	 * @memberof PIXI
3409	 * @name RENDERER_TYPE
3410	 * @enum {number}
3411	 * @property {number} UNKNOWN - Unknown render type.
3412	 * @property {number} WEBGL - WebGL render type.
3413	 * @property {number} CANVAS - Canvas render type.
3414	 */
3415	var RENDERER_TYPE = {
3416	    UNKNOWN:    0,
3417	    WEBGL:      1,
3418	    CANVAS:     2,
3419	};
3420
3421	/**
3422	 * Various blend modes supported by PIXI.
3423	 *
3424	 * IMPORTANT - The WebGL renderer only supports the NORMAL, ADD, MULTIPLY and SCREEN blend modes.
3425	 * Anything else will silently act like NORMAL.
3426	 *
3427	 * @memberof PIXI
3428	 * @name BLEND_MODES
3429	 * @enum {number}
3430	 * @property {number} NORMAL
3431	 * @property {number} ADD
3432	 * @property {number} MULTIPLY
3433	 * @property {number} SCREEN
3434	 * @property {number} OVERLAY
3435	 * @property {number} DARKEN
3436	 * @property {number} LIGHTEN
3437	 * @property {number} COLOR_DODGE
3438	 * @property {number} COLOR_BURN
3439	 * @property {number} HARD_LIGHT
3440	 * @property {number} SOFT_LIGHT
3441	 * @property {number} DIFFERENCE
3442	 * @property {number} EXCLUSION
3443	 * @property {number} HUE
3444	 * @property {number} SATURATION
3445	 * @property {number} COLOR
3446	 * @property {number} LUMINOSITY
3447	 * @property {number} NORMAL_NPM
3448	 * @property {number} ADD_NPM
3449	 * @property {number} SCREEN_NPM
3450	 * @property {number} NONE
3451	 * @property {number} SRC_IN
3452	 * @property {number} SRC_OUT
3453	 * @property {number} SRC_ATOP
3454	 * @property {number} DST_OVER
3455	 * @property {number} DST_IN
3456	 * @property {number} DST_OUT
3457	 * @property {number} DST_ATOP
3458	 * @property {number} SUBTRACT
3459	 * @property {number} SRC_OVER
3460	 * @property {number} ERASE
3461	 */
3462	var BLEND_MODES = {
3463	    NORMAL:         0,
3464	    ADD:            1,
3465	    MULTIPLY:       2,
3466	    SCREEN:         3,
3467	    OVERLAY:        4,
3468	    DARKEN:         5,
3469	    LIGHTEN:        6,
3470	    COLOR_DODGE:    7,
3471	    COLOR_BURN:     8,
3472	    HARD_LIGHT:     9,
3473	    SOFT_LIGHT:     10,
3474	    DIFFERENCE:     11,
3475	    EXCLUSION:      12,
3476	    HUE:            13,
3477	    SATURATION:     14,
3478	    COLOR:          15,
3479	    LUMINOSITY:     16,
3480	    NORMAL_NPM:     17,
3481	    ADD_NPM:        18,
3482	    SCREEN_NPM:     19,
3483	    NONE:           20,
3484
3485	    SRC_OVER:       0,
3486	    SRC_IN:         21,
3487	    SRC_OUT:        22,
3488	    SRC_ATOP:       23,
3489	    DST_OVER:       24,
3490	    DST_IN:         25,
3491	    DST_OUT:        26,
3492	    DST_ATOP:       27,
3493	    ERASE:          26,
3494	    SUBTRACT:       28,
3495	};
3496
3497	/**
3498	 * Various webgl draw modes. These can be used to specify which GL drawMode to use
3499	 * under certain situations and renderers.
3500	 *
3501	 * @memberof PIXI
3502	 * @static
3503	 * @name DRAW_MODES
3504	 * @enum {number}
3505	 * @property {number} POINTS
3506	 * @property {number} LINES
3507	 * @property {number} LINE_LOOP
3508	 * @property {number} LINE_STRIP
3509	 * @property {number} TRIANGLES
3510	 * @property {number} TRIANGLE_STRIP
3511	 * @property {number} TRIANGLE_FAN
3512	 */
3513	var DRAW_MODES = {
3514	    POINTS:         0,
3515	    LINES:          1,
3516	    LINE_LOOP:      2,
3517	    LINE_STRIP:     3,
3518	    TRIANGLES:      4,
3519	    TRIANGLE_STRIP: 5,
3520	    TRIANGLE_FAN:   6,
3521	};
3522
3523	/**
3524	 * Various GL texture/resources formats.
3525	 *
3526	 * @memberof PIXI
3527	 * @static
3528	 * @name FORMATS
3529	 * @enum {number}
3530	 * @property {number} RGBA=6408
3531	 * @property {number} RGB=6407
3532	 * @property {number} ALPHA=6406
3533	 * @property {number} LUMINANCE=6409
3534	 * @property {number} LUMINANCE_ALPHA=6410
3535	 * @property {number} DEPTH_COMPONENT=6402
3536	 * @property {number} DEPTH_STENCIL=34041
3537	 */
3538	var FORMATS = {
3539	    RGBA:             6408,
3540	    RGB:              6407,
3541	    ALPHA:            6406,
3542	    LUMINANCE:        6409,
3543	    LUMINANCE_ALPHA:  6410,
3544	    DEPTH_COMPONENT:  6402,
3545	    DEPTH_STENCIL:    34041,
3546	};
3547
3548	/**
3549	 * Various GL target types.
3550	 *
3551	 * @memberof PIXI
3552	 * @static
3553	 * @name TARGETS
3554	 * @enum {number}
3555	 * @property {number} TEXTURE_2D=3553
3556	 * @property {number} TEXTURE_CUBE_MAP=34067
3557	 * @property {number} TEXTURE_2D_ARRAY=35866
3558	 * @property {number} TEXTURE_CUBE_MAP_POSITIVE_X=34069
3559	 * @property {number} TEXTURE_CUBE_MAP_NEGATIVE_X=34070
3560	 * @property {number} TEXTURE_CUBE_MAP_POSITIVE_Y=34071
3561	 * @property {number} TEXTURE_CUBE_MAP_NEGATIVE_Y=34072
3562	 * @property {number} TEXTURE_CUBE_MAP_POSITIVE_Z=34073
3563	 * @property {number} TEXTURE_CUBE_MAP_NEGATIVE_Z=34074
3564	 */
3565	var TARGETS = {
3566	    TEXTURE_2D: 3553,
3567	    TEXTURE_CUBE_MAP: 34067,
3568	    TEXTURE_2D_ARRAY: 35866,
3569	    TEXTURE_CUBE_MAP_POSITIVE_X: 34069,
3570	    TEXTURE_CUBE_MAP_NEGATIVE_X: 34070,
3571	    TEXTURE_CUBE_MAP_POSITIVE_Y: 34071,
3572	    TEXTURE_CUBE_MAP_NEGATIVE_Y: 34072,
3573	    TEXTURE_CUBE_MAP_POSITIVE_Z: 34073,
3574	    TEXTURE_CUBE_MAP_NEGATIVE_Z: 34074,
3575	};
3576
3577	/**
3578	 * Various GL data format types.
3579	 *
3580	 * @memberof PIXI
3581	 * @static
3582	 * @name TYPES
3583	 * @enum {number}
3584	 * @property {number} UNSIGNED_BYTE=5121
3585	 * @property {number} UNSIGNED_SHORT=5123
3586	 * @property {number} UNSIGNED_SHORT_5_6_5=33635
3587	 * @property {number} UNSIGNED_SHORT_4_4_4_4=32819
3588	 * @property {number} UNSIGNED_SHORT_5_5_5_1=32820
3589	 * @property {number} FLOAT=5126
3590	 * @property {number} HALF_FLOAT=36193
3591	 */
3592	var TYPES = {
3593	    UNSIGNED_BYTE: 5121,
3594	    UNSIGNED_SHORT: 5123,
3595	    UNSIGNED_SHORT_5_6_5: 33635,
3596	    UNSIGNED_SHORT_4_4_4_4: 32819,
3597	    UNSIGNED_SHORT_5_5_5_1: 32820,
3598	    FLOAT: 5126,
3599	    HALF_FLOAT: 36193,
3600	};
3601
3602	/**
3603	 * The scale modes that are supported by pixi.
3604	 *
3605	 * The {@link PIXI.settings.SCALE_MODE} scale mode affects the default scaling mode of future operations.
3606	 * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
3607	 *
3608	 * @memberof PIXI
3609	 * @static
3610	 * @name SCALE_MODES
3611	 * @enum {number}
3612	 * @property {number} LINEAR Smooth scaling
3613	 * @property {number} NEAREST Pixelating scaling
3614	 */
3615	var SCALE_MODES = {
3616	    LINEAR:     1,
3617	    NEAREST:    0,
3618	};
3619
3620	/**
3621	 * The wrap modes that are supported by pixi.
3622	 *
3623	 * The {@link PIXI.settings.WRAP_MODE} wrap mode affects the default wrapping mode of future operations.
3624	 * It can be re-assigned to either CLAMP or REPEAT, depending upon suitability.
3625	 * If the texture is non power of two then clamp will be used regardless as WebGL can
3626	 * only use REPEAT if the texture is po2.
3627	 *
3628	 * This property only affects WebGL.
3629	 *
3630	 * @name WRAP_MODES
3631	 * @memberof PIXI
3632	 * @static
3633	 * @enum {number}
3634	 * @property {number} CLAMP - The textures uvs are clamped
3635	 * @property {number} REPEAT - The texture uvs tile and repeat
3636	 * @property {number} MIRRORED_REPEAT - The texture uvs tile and repeat with mirroring
3637	 */
3638	var WRAP_MODES = {
3639	    CLAMP:           33071,
3640	    REPEAT:          10497,
3641	    MIRRORED_REPEAT: 33648,
3642	};
3643
3644	/**