next
Version:
The React Framework
1,464 lines (1,450 loc) • 717 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to2, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to2, key) && key !== except)
__defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to2;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
// node_modules/.pnpm/tiny-inflate@1.0.3/node_modules/tiny-inflate/index.js
var require_tiny_inflate = __commonJS({
"node_modules/.pnpm/tiny-inflate@1.0.3/node_modules/tiny-inflate/index.js"(exports2, module) {
var TINF_OK = 0;
var TINF_DATA_ERROR = -3;
function Tree() {
this.table = new Uint16Array(16);
this.trans = new Uint16Array(288);
}
function Data(source, dest) {
this.source = source;
this.sourceIndex = 0;
this.tag = 0;
this.bitcount = 0;
this.dest = dest;
this.destLen = 0;
this.ltree = new Tree();
this.dtree = new Tree();
}
var sltree = new Tree();
var sdtree = new Tree();
var length_bits = new Uint8Array(30);
var length_base = new Uint16Array(30);
var dist_bits = new Uint8Array(30);
var dist_base = new Uint16Array(30);
var clcidx = new Uint8Array([
16,
17,
18,
0,
8,
7,
9,
6,
10,
5,
11,
4,
12,
3,
13,
2,
14,
1,
15
]);
var code_tree = new Tree();
var lengths = new Uint8Array(288 + 32);
function tinf_build_bits_base(bits2, base, delta, first) {
var i, sum;
for (i = 0; i < delta; ++i)
bits2[i] = 0;
for (i = 0; i < 30 - delta; ++i)
bits2[i + delta] = i / delta | 0;
for (sum = first, i = 0; i < 30; ++i) {
base[i] = sum;
sum += 1 << bits2[i];
}
}
function tinf_build_fixed_trees(lt, dt) {
var i;
for (i = 0; i < 7; ++i)
lt.table[i] = 0;
lt.table[7] = 24;
lt.table[8] = 152;
lt.table[9] = 112;
for (i = 0; i < 24; ++i)
lt.trans[i] = 256 + i;
for (i = 0; i < 144; ++i)
lt.trans[24 + i] = i;
for (i = 0; i < 8; ++i)
lt.trans[24 + 144 + i] = 280 + i;
for (i = 0; i < 112; ++i)
lt.trans[24 + 144 + 8 + i] = 144 + i;
for (i = 0; i < 5; ++i)
dt.table[i] = 0;
dt.table[5] = 32;
for (i = 0; i < 32; ++i)
dt.trans[i] = i;
}
var offs = new Uint16Array(16);
function tinf_build_tree(t, lengths2, off, num) {
var i, sum;
for (i = 0; i < 16; ++i)
t.table[i] = 0;
for (i = 0; i < num; ++i)
t.table[lengths2[off + i]]++;
t.table[0] = 0;
for (sum = 0, i = 0; i < 16; ++i) {
offs[i] = sum;
sum += t.table[i];
}
for (i = 0; i < num; ++i) {
if (lengths2[off + i])
t.trans[offs[lengths2[off + i]]++] = i;
}
}
function tinf_getbit(d2) {
if (!d2.bitcount--) {
d2.tag = d2.source[d2.sourceIndex++];
d2.bitcount = 7;
}
var bit = d2.tag & 1;
d2.tag >>>= 1;
return bit;
}
function tinf_read_bits(d2, num, base) {
if (!num)
return base;
while (d2.bitcount < 24) {
d2.tag |= d2.source[d2.sourceIndex++] << d2.bitcount;
d2.bitcount += 8;
}
var val = d2.tag & 65535 >>> 16 - num;
d2.tag >>>= num;
d2.bitcount -= num;
return val + base;
}
function tinf_decode_symbol(d2, t) {
while (d2.bitcount < 24) {
d2.tag |= d2.source[d2.sourceIndex++] << d2.bitcount;
d2.bitcount += 8;
}
var sum = 0, cur = 0, len = 0;
var tag = d2.tag;
do {
cur = 2 * cur + (tag & 1);
tag >>>= 1;
++len;
sum += t.table[len];
cur -= t.table[len];
} while (cur >= 0);
d2.tag = tag;
d2.bitcount -= len;
return t.trans[sum + cur];
}
function tinf_decode_trees(d2, lt, dt) {
var hlit, hdist, hclen;
var i, num, length;
hlit = tinf_read_bits(d2, 5, 257);
hdist = tinf_read_bits(d2, 5, 1);
hclen = tinf_read_bits(d2, 4, 4);
for (i = 0; i < 19; ++i)
lengths[i] = 0;
for (i = 0; i < hclen; ++i) {
var clen = tinf_read_bits(d2, 3, 0);
lengths[clcidx[i]] = clen;
}
tinf_build_tree(code_tree, lengths, 0, 19);
for (num = 0; num < hlit + hdist; ) {
var sym = tinf_decode_symbol(d2, code_tree);
switch (sym) {
case 16:
var prev = lengths[num - 1];
for (length = tinf_read_bits(d2, 2, 3); length; --length) {
lengths[num++] = prev;
}
break;
case 17:
for (length = tinf_read_bits(d2, 3, 3); length; --length) {
lengths[num++] = 0;
}
break;
case 18:
for (length = tinf_read_bits(d2, 7, 11); length; --length) {
lengths[num++] = 0;
}
break;
default:
lengths[num++] = sym;
break;
}
}
tinf_build_tree(lt, lengths, 0, hlit);
tinf_build_tree(dt, lengths, hlit, hdist);
}
function tinf_inflate_block_data(d2, lt, dt) {
while (1) {
var sym = tinf_decode_symbol(d2, lt);
if (sym === 256) {
return TINF_OK;
}
if (sym < 256) {
d2.dest[d2.destLen++] = sym;
} else {
var length, dist, offs2;
var i;
sym -= 257;
length = tinf_read_bits(d2, length_bits[sym], length_base[sym]);
dist = tinf_decode_symbol(d2, dt);
offs2 = d2.destLen - tinf_read_bits(d2, dist_bits[dist], dist_base[dist]);
for (i = offs2; i < offs2 + length; ++i) {
d2.dest[d2.destLen++] = d2.dest[i];
}
}
}
}
function tinf_inflate_uncompressed_block(d2) {
var length, invlength;
var i;
while (d2.bitcount > 8) {
d2.sourceIndex--;
d2.bitcount -= 8;
}
length = d2.source[d2.sourceIndex + 1];
length = 256 * length + d2.source[d2.sourceIndex];
invlength = d2.source[d2.sourceIndex + 3];
invlength = 256 * invlength + d2.source[d2.sourceIndex + 2];
if (length !== (~invlength & 65535))
return TINF_DATA_ERROR;
d2.sourceIndex += 4;
for (i = length; i; --i)
d2.dest[d2.destLen++] = d2.source[d2.sourceIndex++];
d2.bitcount = 0;
return TINF_OK;
}
function tinf_uncompress(source, dest) {
var d2 = new Data(source, dest);
var bfinal, btype, res;
do {
bfinal = tinf_getbit(d2);
btype = tinf_read_bits(d2, 2, 0);
switch (btype) {
case 0:
res = tinf_inflate_uncompressed_block(d2);
break;
case 1:
res = tinf_inflate_block_data(d2, sltree, sdtree);
break;
case 2:
tinf_decode_trees(d2, d2.ltree, d2.dtree);
res = tinf_inflate_block_data(d2, d2.ltree, d2.dtree);
break;
default:
res = TINF_DATA_ERROR;
}
if (res !== TINF_OK)
throw new Error("Data error");
} while (!bfinal);
if (d2.destLen < d2.dest.length) {
if (typeof d2.dest.slice === "function")
return d2.dest.slice(0, d2.destLen);
else
return d2.dest.subarray(0, d2.destLen);
}
return d2.dest;
}
tinf_build_fixed_trees(sltree, sdtree);
tinf_build_bits_base(length_bits, length_base, 4, 3);
tinf_build_bits_base(dist_bits, dist_base, 2, 1);
length_bits[28] = 0;
length_base[28] = 258;
module.exports = tinf_uncompress;
}
});
// node_modules/.pnpm/unicode-trie@2.0.0/node_modules/unicode-trie/swap.js
var require_swap = __commonJS({
"node_modules/.pnpm/unicode-trie@2.0.0/node_modules/unicode-trie/swap.js"(exports2, module) {
var isBigEndian = new Uint8Array(new Uint32Array([305419896]).buffer)[0] === 18;
var swap = (b, n, m2) => {
let i = b[n];
b[n] = b[m2];
b[m2] = i;
};
var swap32 = (array) => {
const len = array.length;
for (let i = 0; i < len; i += 4) {
swap(array, i, i + 3);
swap(array, i + 1, i + 2);
}
};
var swap32LE = (array) => {
if (isBigEndian) {
swap32(array);
}
};
module.exports = {
swap32LE
};
}
});
// node_modules/.pnpm/unicode-trie@2.0.0/node_modules/unicode-trie/index.js
var require_unicode_trie = __commonJS({
"node_modules/.pnpm/unicode-trie@2.0.0/node_modules/unicode-trie/index.js"(exports2, module) {
var inflate = require_tiny_inflate();
var { swap32LE } = require_swap();
var SHIFT_1 = 6 + 5;
var SHIFT_2 = 5;
var SHIFT_1_2 = SHIFT_1 - SHIFT_2;
var OMITTED_BMP_INDEX_1_LENGTH = 65536 >> SHIFT_1;
var INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;
var INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;
var INDEX_SHIFT = 2;
var DATA_BLOCK_LENGTH = 1 << SHIFT_2;
var DATA_MASK = DATA_BLOCK_LENGTH - 1;
var LSCP_INDEX_2_OFFSET = 65536 >> SHIFT_2;
var LSCP_INDEX_2_LENGTH = 1024 >> SHIFT_2;
var INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
var UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
var UTF8_2B_INDEX_2_LENGTH = 2048 >> 6;
var INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
var DATA_GRANULARITY = 1 << INDEX_SHIFT;
var UnicodeTrie = class {
constructor(data) {
const isBuffer = typeof data.readUInt32BE === "function" && typeof data.slice === "function";
if (isBuffer || data instanceof Uint8Array) {
let uncompressedLength;
if (isBuffer) {
this.highStart = data.readUInt32LE(0);
this.errorValue = data.readUInt32LE(4);
uncompressedLength = data.readUInt32LE(8);
data = data.slice(12);
} else {
const view = new DataView(data.buffer);
this.highStart = view.getUint32(0, true);
this.errorValue = view.getUint32(4, true);
uncompressedLength = view.getUint32(8, true);
data = data.subarray(12);
}
data = inflate(data, new Uint8Array(uncompressedLength));
data = inflate(data, new Uint8Array(uncompressedLength));
swap32LE(data);
this.data = new Uint32Array(data.buffer);
} else {
({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
}
}
get(codePoint) {
let index;
if (codePoint < 0 || codePoint > 1114111) {
return this.errorValue;
}
if (codePoint < 55296 || codePoint > 56319 && codePoint <= 65535) {
index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index];
}
if (codePoint <= 65535) {
index = (this.data[LSCP_INDEX_2_OFFSET + (codePoint - 55296 >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index];
}
if (codePoint < this.highStart) {
index = this.data[INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH + (codePoint >> SHIFT_1)];
index = this.data[index + (codePoint >> SHIFT_2 & INDEX_2_MASK)];
index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index];
}
return this.data[this.data.length - DATA_GRANULARITY];
}
};
module.exports = UnicodeTrie;
}
});
// node_modules/.pnpm/base64-js@0.0.8/node_modules/base64-js/lib/b64.js
var require_b64 = __commonJS({
"node_modules/.pnpm/base64-js@0.0.8/node_modules/base64-js/lib/b64.js"(exports2) {
var lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
(function(exports3) {
"use strict";
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
var PLUS = "+".charCodeAt(0);
var SLASH = "/".charCodeAt(0);
var NUMBER = "0".charCodeAt(0);
var LOWER = "a".charCodeAt(0);
var UPPER = "A".charCodeAt(0);
var PLUS_URL_SAFE = "-".charCodeAt(0);
var SLASH_URL_SAFE = "_".charCodeAt(0);
function decode2(elt) {
var code = elt.charCodeAt(0);
if (code === PLUS || code === PLUS_URL_SAFE)
return 62;
if (code === SLASH || code === SLASH_URL_SAFE)
return 63;
if (code < NUMBER)
return -1;
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26;
if (code < UPPER + 26)
return code - UPPER;
if (code < LOWER + 26)
return code - LOWER + 26;
}
function b64ToByteArray(b64) {
var i, j, l2, tmp, placeHolders, arr;
if (b64.length % 4 > 0) {
throw new Error("Invalid string. Length must be a multiple of 4");
}
var len = b64.length;
placeHolders = b64.charAt(len - 2) === "=" ? 2 : b64.charAt(len - 1) === "=" ? 1 : 0;
arr = new Arr(b64.length * 3 / 4 - placeHolders);
l2 = placeHolders > 0 ? b64.length - 4 : b64.length;
var L = 0;
function push(v2) {
arr[L++] = v2;
}
for (i = 0, j = 0; i < l2; i += 4, j += 3) {
tmp = decode2(b64.charAt(i)) << 18 | decode2(b64.charAt(i + 1)) << 12 | decode2(b64.charAt(i + 2)) << 6 | decode2(b64.charAt(i + 3));
push((tmp & 16711680) >> 16);
push((tmp & 65280) >> 8);
push(tmp & 255);
}
if (placeHolders === 2) {
tmp = decode2(b64.charAt(i)) << 2 | decode2(b64.charAt(i + 1)) >> 4;
push(tmp & 255);
} else if (placeHolders === 1) {
tmp = decode2(b64.charAt(i)) << 10 | decode2(b64.charAt(i + 1)) << 4 | decode2(b64.charAt(i + 2)) >> 2;
push(tmp >> 8 & 255);
push(tmp & 255);
}
return arr;
}
function uint8ToBase64(uint8) {
var i, extraBytes = uint8.length % 3, output = "", temp, length;
function encode(num) {
return lookup.charAt(num);
}
function tripletToBase64(num) {
return encode(num >> 18 & 63) + encode(num >> 12 & 63) + encode(num >> 6 & 63) + encode(num & 63);
}
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
output += tripletToBase64(temp);
}
switch (extraBytes) {
case 1:
temp = uint8[uint8.length - 1];
output += encode(temp >> 2);
output += encode(temp << 4 & 63);
output += "==";
break;
case 2:
temp = (uint8[uint8.length - 2] << 8) + uint8[uint8.length - 1];
output += encode(temp >> 10);
output += encode(temp >> 4 & 63);
output += encode(temp << 2 & 63);
output += "=";
break;
}
return output;
}
exports3.toByteArray = b64ToByteArray;
exports3.fromByteArray = uint8ToBase64;
})(typeof exports2 === "undefined" ? exports2.base64js = {} : exports2);
}
});
// node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/parse.js
var require_parse = __commonJS({
"node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/parse.js"(exports2, module) {
var openParentheses = "(".charCodeAt(0);
var closeParentheses = ")".charCodeAt(0);
var singleQuote = "'".charCodeAt(0);
var doubleQuote = '"'.charCodeAt(0);
var backslash = "\\".charCodeAt(0);
var slash = "/".charCodeAt(0);
var comma = ",".charCodeAt(0);
var colon = ":".charCodeAt(0);
var star = "*".charCodeAt(0);
var uLower = "u".charCodeAt(0);
var uUpper = "U".charCodeAt(0);
var plus = "+".charCodeAt(0);
var isUnicodeRange = /^[a-f0-9?-]+$/i;
module.exports = function(input) {
var tokens = [];
var value = input;
var next, quote, prev, token, escape, escapePos, whitespacePos, parenthesesOpenPos;
var pos = 0;
var code = value.charCodeAt(pos);
var max2 = value.length;
var stack = [{ nodes: tokens }];
var balanced = 0;
var parent;
var name = "";
var before = "";
var after = "";
while (pos < max2) {
if (code <= 32) {
next = pos;
do {
next += 1;
code = value.charCodeAt(next);
} while (code <= 32);
token = value.slice(pos, next);
prev = tokens[tokens.length - 1];
if (code === closeParentheses && balanced) {
after = token;
} else if (prev && prev.type === "div") {
prev.after = token;
prev.sourceEndIndex += token.length;
} else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star && (!parent || parent && parent.type === "function" && parent.value !== "calc")) {
before = token;
} else {
tokens.push({
type: "space",
sourceIndex: pos,
sourceEndIndex: next,
value: token
});
}
pos = next;
} else if (code === singleQuote || code === doubleQuote) {
next = pos;
quote = code === singleQuote ? "'" : '"';
token = {
type: "string",
sourceIndex: pos,
quote
};
do {
escape = false;
next = value.indexOf(quote, next + 1);
if (~next) {
escapePos = next;
while (value.charCodeAt(escapePos - 1) === backslash) {
escapePos -= 1;
escape = !escape;
}
} else {
value += quote;
next = value.length - 1;
token.unclosed = true;
}
} while (escape);
token.value = value.slice(pos + 1, next);
token.sourceEndIndex = token.unclosed ? next : next + 1;
tokens.push(token);
pos = next + 1;
code = value.charCodeAt(pos);
} else if (code === slash && value.charCodeAt(pos + 1) === star) {
next = value.indexOf("*/", pos);
token = {
type: "comment",
sourceIndex: pos,
sourceEndIndex: next + 2
};
if (next === -1) {
token.unclosed = true;
next = value.length;
token.sourceEndIndex = next;
}
token.value = value.slice(pos + 2, next);
tokens.push(token);
pos = next + 2;
code = value.charCodeAt(pos);
} else if ((code === slash || code === star) && parent && parent.type === "function" && parent.value === "calc") {
token = value[pos];
tokens.push({
type: "word",
sourceIndex: pos - before.length,
sourceEndIndex: pos + token.length,
value: token
});
pos += 1;
code = value.charCodeAt(pos);
} else if (code === slash || code === comma || code === colon) {
token = value[pos];
tokens.push({
type: "div",
sourceIndex: pos - before.length,
sourceEndIndex: pos + token.length,
value: token,
before,
after: ""
});
before = "";
pos += 1;
code = value.charCodeAt(pos);
} else if (openParentheses === code) {
next = pos;
do {
next += 1;
code = value.charCodeAt(next);
} while (code <= 32);
parenthesesOpenPos = pos;
token = {
type: "function",
sourceIndex: pos - name.length,
value: name,
before: value.slice(parenthesesOpenPos + 1, next)
};
pos = next;
if (name === "url" && code !== singleQuote && code !== doubleQuote) {
next -= 1;
do {
escape = false;
next = value.indexOf(")", next + 1);
if (~next) {
escapePos = next;
while (value.charCodeAt(escapePos - 1) === backslash) {
escapePos -= 1;
escape = !escape;
}
} else {
value += ")";
next = value.length - 1;
token.unclosed = true;
}
} while (escape);
whitespacePos = next;
do {
whitespacePos -= 1;
code = value.charCodeAt(whitespacePos);
} while (code <= 32);
if (parenthesesOpenPos < whitespacePos) {
if (pos !== whitespacePos + 1) {
token.nodes = [
{
type: "word",
sourceIndex: pos,
sourceEndIndex: whitespacePos + 1,
value: value.slice(pos, whitespacePos + 1)
}
];
} else {
token.nodes = [];
}
if (token.unclosed && whitespacePos + 1 !== next) {
token.after = "";
token.nodes.push({
type: "space",
sourceIndex: whitespacePos + 1,
sourceEndIndex: next,
value: value.slice(whitespacePos + 1, next)
});
} else {
token.after = value.slice(whitespacePos + 1, next);
token.sourceEndIndex = next;
}
} else {
token.after = "";
token.nodes = [];
}
pos = next + 1;
token.sourceEndIndex = token.unclosed ? next : pos;
code = value.charCodeAt(pos);
tokens.push(token);
} else {
balanced += 1;
token.after = "";
token.sourceEndIndex = pos + 1;
tokens.push(token);
stack.push(token);
tokens = token.nodes = [];
parent = token;
}
name = "";
} else if (closeParentheses === code && balanced) {
pos += 1;
code = value.charCodeAt(pos);
parent.after = after;
parent.sourceEndIndex += after.length;
after = "";
balanced -= 1;
stack[stack.length - 1].sourceEndIndex = pos;
stack.pop();
parent = stack[balanced];
tokens = parent.nodes;
} else {
next = pos;
do {
if (code === backslash) {
next += 1;
}
next += 1;
code = value.charCodeAt(next);
} while (next < max2 && !(code <= 32 || code === singleQuote || code === doubleQuote || code === comma || code === colon || code === slash || code === openParentheses || code === star && parent && parent.type === "function" && parent.value === "calc" || code === slash && parent.type === "function" && parent.value === "calc" || code === closeParentheses && balanced));
token = value.slice(pos, next);
if (openParentheses === code) {
name = token;
} else if ((uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && plus === token.charCodeAt(1) && isUnicodeRange.test(token.slice(2))) {
tokens.push({
type: "unicode-range",
sourceIndex: pos,
sourceEndIndex: next,
value: token
});
} else {
tokens.push({
type: "word",
sourceIndex: pos,
sourceEndIndex: next,
value: token
});
}
pos = next;
}
}
for (pos = stack.length - 1; pos; pos -= 1) {
stack[pos].unclosed = true;
stack[pos].sourceEndIndex = value.length;
}
return stack[0].nodes;
};
}
});
// node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/walk.js
var require_walk = __commonJS({
"node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/walk.js"(exports2, module) {
module.exports = function walk(nodes, cb, bubble) {
var i, max2, node, result;
for (i = 0, max2 = nodes.length; i < max2; i += 1) {
node = nodes[i];
if (!bubble) {
result = cb(node, i, nodes);
}
if (result !== false && node.type === "function" && Array.isArray(node.nodes)) {
walk(node.nodes, cb, bubble);
}
if (bubble) {
cb(node, i, nodes);
}
}
};
}
});
// node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/stringify.js
var require_stringify = __commonJS({
"node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/stringify.js"(exports2, module) {
function stringifyNode(node, custom) {
var type = node.type;
var value = node.value;
var buf;
var customResult;
if (custom && (customResult = custom(node)) !== void 0) {
return customResult;
} else if (type === "word" || type === "space") {
return value;
} else if (type === "string") {
buf = node.quote || "";
return buf + value + (node.unclosed ? "" : buf);
} else if (type === "comment") {
return "/*" + value + (node.unclosed ? "" : "*/");
} else if (type === "div") {
return (node.before || "") + value + (node.after || "");
} else if (Array.isArray(node.nodes)) {
buf = stringify(node.nodes, custom);
if (type !== "function") {
return buf;
}
return value + "(" + (node.before || "") + buf + (node.after || "") + (node.unclosed ? "" : ")");
}
return value;
}
function stringify(nodes, custom) {
var result, i;
if (Array.isArray(nodes)) {
result = "";
for (i = nodes.length - 1; ~i; i -= 1) {
result = stringifyNode(nodes[i], custom) + result;
}
return result;
}
return stringifyNode(nodes, custom);
}
module.exports = stringify;
}
});
// node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/unit.js
var require_unit = __commonJS({
"node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/unit.js"(exports2, module) {
var minus = "-".charCodeAt(0);
var plus = "+".charCodeAt(0);
var dot = ".".charCodeAt(0);
var exp = "e".charCodeAt(0);
var EXP = "E".charCodeAt(0);
function likeNumber(value) {
var code = value.charCodeAt(0);
var nextCode;
if (code === plus || code === minus) {
nextCode = value.charCodeAt(1);
if (nextCode >= 48 && nextCode <= 57) {
return true;
}
var nextNextCode = value.charCodeAt(2);
if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
return true;
}
return false;
}
if (code === dot) {
nextCode = value.charCodeAt(1);
if (nextCode >= 48 && nextCode <= 57) {
return true;
}
return false;
}
if (code >= 48 && code <= 57) {
return true;
}
return false;
}
module.exports = function(value) {
var pos = 0;
var length = value.length;
var code;
var nextCode;
var nextNextCode;
if (length === 0 || !likeNumber(value)) {
return false;
}
code = value.charCodeAt(pos);
if (code === plus || code === minus) {
pos++;
}
while (pos < length) {
code = value.charCodeAt(pos);
if (code < 48 || code > 57) {
break;
}
pos += 1;
}
code = value.charCodeAt(pos);
nextCode = value.charCodeAt(pos + 1);
if (code === dot && nextCode >= 48 && nextCode <= 57) {
pos += 2;
while (pos < length) {
code = value.charCodeAt(pos);
if (code < 48 || code > 57) {
break;
}
pos += 1;
}
}
code = value.charCodeAt(pos);
nextCode = value.charCodeAt(pos + 1);
nextNextCode = value.charCodeAt(pos + 2);
if ((code === exp || code === EXP) && (nextCode >= 48 && nextCode <= 57 || (nextCode === plus || nextCode === minus) && nextNextCode >= 48 && nextNextCode <= 57)) {
pos += nextCode === plus || nextCode === minus ? 3 : 2;
while (pos < length) {
code = value.charCodeAt(pos);
if (code < 48 || code > 57) {
break;
}
pos += 1;
}
}
return {
number: value.slice(0, pos),
unit: value.slice(pos)
};
};
}
});
// node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/index.js
var require_lib = __commonJS({
"node_modules/.pnpm/postcss-value-parser@4.2.0/node_modules/postcss-value-parser/lib/index.js"(exports2, module) {
var parse2 = require_parse();
var walk = require_walk();
var stringify = require_stringify();
function ValueParser(value) {
if (this instanceof ValueParser) {
this.nodes = parse2(value);
return this;
}
return new ValueParser(value);
}
ValueParser.prototype.toString = function() {
return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
};
ValueParser.prototype.walk = function(cb, bubble) {
walk(this.nodes, cb, bubble);
return this;
};
ValueParser.unit = require_unit();
ValueParser.walk = walk;
ValueParser.stringify = stringify;
module.exports = ValueParser;
}
});
// node_modules/.pnpm/camelize@1.0.0/node_modules/camelize/index.js
var require_camelize = __commonJS({
"node_modules/.pnpm/camelize@1.0.0/node_modules/camelize/index.js"(exports2, module) {
module.exports = function(obj) {
if (typeof obj === "string")
return camelCase(obj);
return walk(obj);
};
function walk(obj) {
if (!obj || typeof obj !== "object")
return obj;
if (isDate(obj) || isRegex(obj))
return obj;
if (isArray(obj))
return map(obj, walk);
return reduce(objectKeys(obj), function(acc, key) {
var camel = camelCase(key);
acc[camel] = walk(obj[key]);
return acc;
}, {});
}
function camelCase(str) {
return str.replace(/[_.-](\w|$)/g, function(_, x2) {
return x2.toUpperCase();
});
}
var isArray = Array.isArray || function(obj) {
return Object.prototype.toString.call(obj) === "[object Array]";
};
var isDate = function(obj) {
return Object.prototype.toString.call(obj) === "[object Date]";
};
var isRegex = function(obj) {
return Object.prototype.toString.call(obj) === "[object RegExp]";
};
var has = Object.prototype.hasOwnProperty;
var objectKeys = Object.keys || function(obj) {
var keys = [];
for (var key in obj) {
if (has.call(obj, key))
keys.push(key);
}
return keys;
};
function map(xs, f) {
if (xs.map)
return xs.map(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
res.push(f(xs[i], i));
}
return res;
}
function reduce(xs, f, acc) {
if (xs.reduce)
return xs.reduce(f, acc);
for (var i = 0; i < xs.length; i++) {
acc = f(acc, xs[i], i);
}
return acc;
}
}
});
// node_modules/.pnpm/css-color-keywords@1.0.0/node_modules/css-color-keywords/colors.json
var require_colors = __commonJS({
"node_modules/.pnpm/css-color-keywords@1.0.0/node_modules/css-color-keywords/colors.json"(exports2, module) {
module.exports = {
black: "#000000",
silver: "#c0c0c0",
gray: "#808080",
white: "#ffffff",
maroon: "#800000",
red: "#ff0000",
purple: "#800080",
fuchsia: "#ff00ff",
green: "#008000",
lime: "#00ff00",
olive: "#808000",
yellow: "#ffff00",
navy: "#000080",
blue: "#0000ff",
teal: "#008080",
aqua: "#00ffff",
orange: "#ffa500",
aliceblue: "#f0f8ff",
antiquewhite: "#faebd7",
aquamarine: "#7fffd4",
azure: "#f0ffff",
beige: "#f5f5dc",
bisque: "#ffe4c4",
blanchedalmond: "#ffebcd",
blueviolet: "#8a2be2",
brown: "#a52a2a",
burlywood: "#deb887",
cadetblue: "#5f9ea0",
chartreuse: "#7fff00",
chocolate: "#d2691e",
coral: "#ff7f50",
cornflowerblue: "#6495ed",
cornsilk: "#fff8dc",
crimson: "#dc143c",
darkblue: "#00008b",
darkcyan: "#008b8b",
darkgoldenrod: "#b8860b",
darkgray: "#a9a9a9",
darkgreen: "#006400",
darkgrey: "#a9a9a9",
darkkhaki: "#bdb76b",
darkmagenta: "#8b008b",
darkolivegreen: "#556b2f",
darkorange: "#ff8c00",
darkorchid: "#9932cc",
darkred: "#8b0000",
darksalmon: "#e9967a",
darkseagreen: "#8fbc8f",
darkslateblue: "#483d8b",
darkslategray: "#2f4f4f",
darkslategrey: "#2f4f4f",
darkturquoise: "#00ced1",
darkviolet: "#9400d3",
deeppink: "#ff1493",
deepskyblue: "#00bfff",
dimgray: "#696969",
dimgrey: "#696969",
dodgerblue: "#1e90ff",
firebrick: "#b22222",
floralwhite: "#fffaf0",
forestgreen: "#228b22",
gainsboro: "#dcdcdc",
ghostwhite: "#f8f8ff",
gold: "#ffd700",
goldenrod: "#daa520",
greenyellow: "#adff2f",
grey: "#808080",
honeydew: "#f0fff0",
hotpink: "#ff69b4",
indianred: "#cd5c5c",
indigo: "#4b0082",
ivory: "#fffff0",
khaki: "#f0e68c",
lavender: "#e6e6fa",
lavenderblush: "#fff0f5",
lawngreen: "#7cfc00",
lemonchiffon: "#fffacd",
lightblue: "#add8e6",
lightcoral: "#f08080",
lightcyan: "#e0ffff",
lightgoldenrodyellow: "#fafad2",
lightgray: "#d3d3d3",
lightgreen: "#90ee90",
lightgrey: "#d3d3d3",
lightpink: "#ffb6c1",
lightsalmon: "#ffa07a",
lightseagreen: "#20b2aa",
lightskyblue: "#87cefa",
lightslategray: "#778899",
lightslategrey: "#778899",
lightsteelblue: "#b0c4de",
lightyellow: "#ffffe0",
limegreen: "#32cd32",
linen: "#faf0e6",
mediumaquamarine: "#66cdaa",
mediumblue: "#0000cd",
mediumorchid: "#ba55d3",
mediumpurple: "#9370db",
mediumseagreen: "#3cb371",
mediumslateblue: "#7b68ee",
mediumspringgreen: "#00fa9a",
mediumturquoise: "#48d1cc",
mediumvioletred: "#c71585",
midnightblue: "#191970",
mintcream: "#f5fffa",
mistyrose: "#ffe4e1",
moccasin: "#ffe4b5",
navajowhite: "#ffdead",
oldlace: "#fdf5e6",
olivedrab: "#6b8e23",
orangered: "#ff4500",
orchid: "#da70d6",
palegoldenrod: "#eee8aa",
palegreen: "#98fb98",
paleturquoise: "#afeeee",
palevioletred: "#db7093",
papayawhip: "#ffefd5",
peachpuff: "#ffdab9",
peru: "#cd853f",
pink: "#ffc0cb",
plum: "#dda0dd",
powderblue: "#b0e0e6",
rosybrown: "#bc8f8f",
royalblue: "#4169e1",
saddlebrown: "#8b4513",
salmon: "#fa8072",
sandybrown: "#f4a460",
seagreen: "#2e8b57",
seashell: "#fff5ee",
sienna: "#a0522d",
skyblue: "#87ceeb",
slateblue: "#6a5acd",
slategray: "#708090",
slategrey: "#708090",
snow: "#fffafa",
springgreen: "#00ff7f",
steelblue: "#4682b4",
tan: "#d2b48c",
thistle: "#d8bfd8",
tomato: "#ff6347",
turquoise: "#40e0d0",
violet: "#ee82ee",
wheat: "#f5deb3",
whitesmoke: "#f5f5f5",
yellowgreen: "#9acd32",
rebeccapurple: "#663399"
};
}
});
// node_modules/.pnpm/css-color-keywords@1.0.0/node_modules/css-color-keywords/index.js
var require_css_color_keywords = __commonJS({
"node_modules/.pnpm/css-color-keywords@1.0.0/node_modules/css-color-keywords/index.js"(exports2, module) {
"use strict";
module.exports = require_colors();
}
});
// node_modules/.pnpm/css-to-react-native@3.0.0/node_modules/css-to-react-native/index.js
var require_css_to_react_native = __commonJS({
"node_modules/.pnpm/css-to-react-native@3.0.0/node_modules/css-to-react-native/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", {
value: true
});
function _interopDefault(ex) {
return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex;
}
var parse2 = require_lib();
var parse__default = _interopDefault(parse2);
var camelizeStyleName = _interopDefault(require_camelize());
var cssColorKeywords = _interopDefault(require_css_color_keywords());
var matchString = function matchString2(node) {
if (node.type !== "string")
return null;
return node.value.replace(/\\([0-9a-f]{1,6})(?:\s|$)/gi, function(match, charCode) {
return String.fromCharCode(parseInt(charCode, 16));
}).replace(/\\/g, "");
};
var hexColorRe = /^(#(?:[0-9a-f]{3,4}){1,2})$/i;
var cssFunctionNameRe = /^(rgba?|hsla?|hwb|lab|lch|gray|color)$/;
var matchColor = function matchColor2(node) {
if (node.type === "word" && (hexColorRe.test(node.value) || node.value in cssColorKeywords || node.value === "transparent")) {
return node.value;
} else if (node.type === "function" && cssFunctionNameRe.test(node.value)) {
return parse2.stringify(node);
}
return null;
};
var noneRe = /^(none)$/i;
var autoRe = /^(auto)$/i;
var identRe = /(^-?[_a-z][_a-z0-9-]*$)/i;
var numberRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?)$/i;
var lengthRe = /^(0$|(?:[+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?)(?=px$))/i;
var unsupportedUnitRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?(ch|em|ex|rem|vh|vw|vmin|vmax|cm|mm|in|pc|pt))$/i;
var angleRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?(?:deg|rad))$/i;
var percentRe = /^([+-]?(?:\d*\.)?\d+(?:e[+-]?\d+)?%)$/i;
var noopToken = function noopToken2(predicate) {
return function(node) {
return predicate(node) ? "<token>" : null;
};
};
var valueForTypeToken = function valueForTypeToken2(type) {
return function(node) {
return node.type === type ? node.value : null;
};
};
var regExpToken = function regExpToken2(regExp, transform2) {
if (transform2 === void 0) {
transform2 = String;
}
return function(node) {
if (node.type !== "word")
return null;
var match = node.value.match(regExp);
if (match === null)
return null;
var value = transform2(match[1]);
return value;
};
};
var SPACE = noopToken(function(node) {
return node.type === "space";
});
var SLASH = noopToken(function(node) {
return node.type === "div" && node.value === "/";
});
var COMMA = noopToken(function(node) {
return node.type === "div" && node.value === ",";
});
var WORD = valueForTypeToken("word");
var NONE = regExpToken(noneRe);
var AUTO = regExpToken(autoRe);
var NUMBER = regExpToken(numberRe, Number);
var LENGTH = regExpToken(lengthRe, Number);
var UNSUPPORTED_LENGTH_UNIT = regExpToken(unsupportedUnitRe);
var ANGLE = regExpToken(angleRe, function(angle) {
return angle.toLowerCase();
});
var PERCENT = regExpToken(percentRe);
var IDENT = regExpToken(identRe);
var STRING = matchString;
var COLOR = matchColor;
var LINE = regExpToken(/^(none|underline|line-through)$/i);
var BORDER_STYLE = regExpToken(/^(solid|dashed|dotted)$/);
var defaultBorderWidth = 1;
var defaultBorderColor = "black";
var defaultBorderStyle = "solid";
var border = function border2(tokenStream) {
var borderWidth2;
var borderColor2;
var borderStyle;
if (tokenStream.matches(NONE)) {
tokenStream.expectEmpty();
return {
borderWidth: 0,
borderColor: "black",
borderStyle: "solid"
};
}
var partsParsed = 0;
while (partsParsed < 3 && tokenStream.hasTokens()) {
if (partsParsed !== 0)
tokenStream.expect(SPACE);
if (borderWidth2 === void 0 && tokenStream.matches(LENGTH, UNSUPPORTED_LENGTH_UNIT)) {
borderWidth2 = tokenStream.lastValue;
} else if (borderColor2 === void 0 && tokenStream.matches(COLOR)) {
borderColor2 = tokenStream.lastValue;
} else if (borderStyle === void 0 && tokenStream.matches(BORDER_STYLE)) {
borderStyle = tokenStream.lastValue;
} else {
tokenStream["throw"]();
}
partsParsed += 1;
}
tokenStream.expectEmpty();
if (borderWidth2 === void 0)
borderWidth2 = defaultBorderWidth;
if (borderColor2 === void 0)
borderColor2 = defaultBorderColor;
if (borderStyle === void 0)
borderStyle = defaultBorderStyle;
return {
borderWidth: borderWidth2,
borderColor: borderColor2,
borderStyle
};
};
var directionFactory = function directionFactory2(_ref) {
var _ref$types = _ref.types, types = _ref$types === void 0 ? [LENGTH, UNSUPPORTED_LENGTH_UNIT, PERCENT] : _ref$types, _ref$directions = _ref.directions, directions = _ref$directions === void 0 ? ["Top", "Right", "Bottom", "Left"] : _ref$directions, _ref$prefix = _ref.prefix, prefix = _ref$prefix === void 0 ? "" : _ref$prefix, _ref$suffix = _ref.suffix, suffix = _ref$suffix === void 0 ? "" : _ref$suffix;
return function(tokenStream) {
var _ref2;
var values = [];
values.push(tokenStream.expect.apply(tokenStream, types));
while (values.length < 4 && tokenStream.hasTokens()) {
tokenStream.expect(SPACE);
values.push(tokenStream.expect.apply(tokenStream, types));
}
tokenStream.expectEmpty();
var top = values[0], _values$ = values[1], right = _values$ === void 0 ? top : _values$, _values$2 = values[2], bottom = _values$2 === void 0 ? top : _values$2, _values$3 = values[3], left = _values$3 === void 0 ? right : _values$3;
var keyFor = function keyFor2(n) {
return "" + prefix + directions[n] + suffix;
};
return _ref2 = {}, _ref2[keyFor(0)] = top, _ref2[keyFor(1)] = right, _ref2[keyFor(2)] = bottom, _ref2[keyFor(3)] = left, _ref2;
};
};
var parseShadowOffset = function parseShadowOffset2(tokenStream) {
var width = tokenStream.expect(LENGTH);
var height = tokenStream.matches(SPACE) ? tokenStream.expect(LENGTH) : width;
tokenStream.expectEmpty();
return {
width,
height
};
};
var parseShadow = function parseShadow2(tokenStream) {
var offsetX;
var offsetY;
var radius;
var color;
if (tokenStream.matches(NONE)) {
tokenStream.expectEmpty();
return {
offset: {
width: 0,
height: 0
},
radius: 0,
color: "black"
};
}
var didParseFirst = false;
while (tokenStream.hasTokens()) {
if (didParseFirst)
tokenStream.expect(SPACE);
if (offsetX === void 0 && tokenStream.matches(LENGTH, UNSUPPORTED_LENGTH_UNIT)) {
offsetX = tokenStream.lastValue;
tokenStream.expect(SPACE);
offsetY = tokenStream.expect(LENGTH, UNSUPPORTED_LENGTH_UNIT);
tokenStream.saveRewindPoint();
if (tokenStream.matches(SPACE) && tokenStream.matches(LENGTH, UNSUPPORTED_LENGTH_UNIT)) {
radius = tokenStream.lastValue;
} else {
tokenStream.rewind();
}
} else if (color === void 0 && tokenStream.matches(COLOR)) {
color = tokenStream.lastValue;
} else {
tokenStream["throw"]();
}
didParseFirst = true;
}
if (offsetX === void 0)
tokenStream["throw"]();
return {
offset: {
width: offsetX,
height: offsetY
},
radius: radius !== void 0 ? radius : 0,
color: color !== void 0 ? color : "black"
};
};
var boxShadow = function boxShadow2(tokenStream) {
var _parseShadow = parseShadow(tokenStream), offset = _parseShadow.offset, radius = _parseShadow.radius, color = _parseShadow.color;
return {
shadowOffset: offset,
shadowRadius: radius,
shadowColor: color,
shadowOpacity: 1
};
};
var defaultFlexGrow = 1;
var defaultFlexShrink = 1;
var defaultFlexBasis = 0;
var flex = function flex2(tokenStream) {
var flexGrow;
var flexShrink;
var flexBasis;
if (tokenStream.matches(NONE)) {
tokenStream.expectEmpty();
return {
flexGrow: 0,
flexShrink: 0,
flexBasis: "auto"
};
}
tokenStream.saveRewindPoint();
if (tokenStream.matches(AUTO) && !tokenStream.hasTokens()) {
return {
flexGrow: 1,
flexShrink: 1,
flexBasis: "auto"
};
}
tokenStream.rewind();
var partsParsed = 0;
while (partsParsed < 2 && tokenStream.hasTokens()) {
if (partsParsed !== 0)
tokenStream.expect(SPACE);
if (flexGrow === void 0 && tokenStream.matches(NUMBER)) {
flexGrow = tokenStream.lastValue;
tokenStream.saveRewindPoint();
if (tokenStream.matches(SPACE) && tokenStream.matches(NUMBER)) {
flexShrink = tokenStream.lastValue;
} else {
tokenStream.rewind();
}
} else if (flexBasis === void 0 && tokenStream.matches(LENGTH, UNSUPPORTED_LENGTH_UNIT, PERCENT)) {
flexBasis = tokenStream.lastValue;
} else if (flexBasis === void 0 && tokenStream.matches(AUTO)) {
flexBasis = "auto";
} else {
tokenStream["throw"]();
}
partsParsed += 1;
}
tokenStream.expectEmpty();
if (flexGrow === void 0)
flexGrow = defaultFlexGrow;
if (flexShrink === void 0)
flexShrink = defaultFlexShrink;
if (flexBasis === void 0)
flexBasis = defaultFlexBasis;
return {
flexGrow,
flexShrink,
flexBasis
};
};
var FLEX_WRAP = regExpToken(/(nowrap|wrap|wrap-reverse)/);
var FLEX_DIRECTION = regExpToken(/(row|row-reverse|column|column-reverse)/);
var defaultFlexWrap = "nowrap";
var defaultFlexDirection = "row";
var flexFlow = function flexFlow2(tokenStream) {
var flexWrap;
var flexDirection;
var partsParsed = 0;
while (partsParsed < 2 && tokenStream.hasTokens()) {
if (partsParsed !== 0)
tokenStream.expect(SPACE);
if (flexWrap === void 0 && tokenStream.matches(FLEX_WRAP)) {
flexWrap = tokenStream.lastValue;
} else if (flexDirection === void 0 && tokenStream.matches(FLEX_DIRECTION)) {
flexDirection = tokenStream.lastValue;
} else {
tokenStream["throw"]();
}
partsParsed += 1;
}
tokenStream.expectEmpty();
if (flexWrap === void 0)
flexWrap = defaultFlexWrap;
if (flexDirection === void 0)
flexDirection = defaultFlexDirection;
return {
flexWrap,
flexDirection
};
};
var fontFamily = function fontFamily2(tokenStream) {
var fontFamily3;
if (tokenStream.matches(STRING)) {
fontFamily3 = tokenStream.lastValue;
} else {
fontFamily3 = tokenStream.expect(IDENT);
while (tokenStream.hasTokens()) {
tokenStream.expect(SPACE);
var nextIdent = tokenStream.expect(IDENT);
fontFamily3 += " " + nextIdent;
}
}
tokenStream.expectEmpty();
return {
fontFamily: fontFamily3
};
};
var NORMAL = regExpToken(/^(normal)$/);
var STYLE = regExpToken(/^(italic)$/);
var WEIGHT = regExpToken(/^([1-9]00|bold)$/);
var VARIANT = regExpToken(/^(small-caps)$/);
var defaultFontStyle = "normal";
var defaultFontWeight = "normal";
var defaultFontVariant = [];
var font = function font2(tokenStream) {
var fontStyle;
var fontWeight2;
var fontVariant2;
var lineHeight;
var numStyleWeightVariantMatched = 0;
while (numStyleWeightVariantMatched < 3 && tokenStream.hasTokens()) {
if (tokenStream.matches(NORMAL))
;
else if (fontStyle === void 0 && tokenStream.matches(STYLE)) {
fontStyle = tokenStream.lastValue;
} else if (fontWeight2 === void 0 && tokenStream.matches(WEIGHT)) {