673 lines
24 KiB
JavaScript
673 lines
24 KiB
JavaScript
// Module ID: 1556
|
|
// Function ID: 1557
|
|
// Name: validateArrayFormatSeparator
|
|
// Dependencies: [32, 1557, 1558, 1559, 1560]
|
|
// Exports: exclude, extract, parseUrl, pick, stringify, stringifyUrl
|
|
|
|
// Module 1556 (validateArrayFormatSeparator)
|
|
import _mod1557 from "module_1557" /* 1557 */;
|
|
import decodeComponents from "decodeComponents" /* 1558 */;
|
|
import _mod1559 from "module_1559" /* 1559 */;
|
|
import _mod1560 from "module_1560" /* 1560 */;
|
|
import closure_3 from "_slicedToArray" /* 32 */;
|
|
|
|
function validateArrayFormatSeparator(arrayFormatSeparator) {
|
|
const typeError = new TypeError("arrayFormatSeparator must be single character string");
|
|
throw typeError;
|
|
}
|
|
function decode(arg0, decode) {
|
|
let tmp = arg0;
|
|
if (decode.decode) {
|
|
tmp = decodeComponents(arg0);
|
|
}
|
|
return tmp;
|
|
}
|
|
function keysSorter(arr) {
|
|
closure_0 = arr;
|
|
if (Array.isArray(arr)) {
|
|
let sorted = arr.sort();
|
|
} else {
|
|
sorted = arr;
|
|
if (typeof arr === "object") {
|
|
const _Object = Object;
|
|
const sorted1 = keysSorter(Object.keys(arr)).sort((arg0, arg1) => Number(arg0) - Number(arg1));
|
|
sorted = sorted1.map((arg0) => keys[arg0]);
|
|
const obj = keysSorter(Object.keys(arr));
|
|
}
|
|
}
|
|
return sorted;
|
|
}
|
|
function parseValue(str, parseNumbers) {
|
|
if (parseNumbers.parseNumbers) {
|
|
const _Number = Number;
|
|
const _Number2 = Number;
|
|
if (!Number.isNaN(Number(str))) {
|
|
if (typeof str === "string") {
|
|
if ("" !== str.trim()) {
|
|
const _Number3 = Number;
|
|
let NumberResult = Number(str);
|
|
}
|
|
return NumberResult;
|
|
}
|
|
}
|
|
}
|
|
const parseBooleans = parseNumbers.parseBooleans;
|
|
let tmp3 = !parseBooleans;
|
|
if (parseBooleans) {
|
|
tmp3 = null === str;
|
|
}
|
|
if (!tmp3) {
|
|
let tmp5 = "true" !== str.toLowerCase();
|
|
if (tmp5) {
|
|
tmp5 = "false" !== str.toLowerCase();
|
|
}
|
|
tmp3 = tmp5;
|
|
}
|
|
NumberResult = str;
|
|
if (!tmp3) {
|
|
NumberResult = "true" === str.toLowerCase();
|
|
}
|
|
}
|
|
function parse(str) {
|
|
let obj = globalThis;
|
|
const merged = Object.assign({ decode: true, sort: true, arrayFormat: "none", arrayFormatSeparator: ",", parseNumbers: false, parseBooleans: false }, arg1);
|
|
validateArrayFormatSeparator(merged.arrayFormatSeparator);
|
|
obj = Object.create(null);
|
|
if (typeof str !== "string") {
|
|
return obj;
|
|
} else {
|
|
const str7 = str.trim().replace(/^[?#&]/, "");
|
|
if (str7) {
|
|
let parts = str7.split("&");
|
|
const iter = parts[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let str4 = nextResult;
|
|
if ("" !== nextResult) {
|
|
let tmp43 = obj;
|
|
let tmp44 = dependencyMap;
|
|
let tmp46 = nextResult;
|
|
let tmp45 = obj(1559);
|
|
if (merged.decode) {
|
|
let replaced = str4.replace(/\+/g, " ");
|
|
} else {
|
|
replaced = str4;
|
|
}
|
|
let tmp12 = callback;
|
|
let tmp13 = callback(tmp45(replaced, "="), 2);
|
|
[tmp14, tmp15] = tmp13;
|
|
let tmp17 = null;
|
|
if (undefined === tmp15) {
|
|
let tmp22 = null;
|
|
let tmp23 = decode;
|
|
let tmp24 = tmp14;
|
|
let tmp4Result = tmp4(decode(tmp14, merged), null, obj);
|
|
} else {
|
|
let items = ["comma", "separator", "bracket-separator"];
|
|
if (items.includes(merged.arrayFormat)) {
|
|
let tmp20 = tmp15;
|
|
} else {
|
|
let tmp18 = decode;
|
|
let tmp19 = tmp15;
|
|
tmp20 = decode(tmp16, merged);
|
|
}
|
|
let tmp21 = tmp20;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
let _Object = Object;
|
|
let keys = Object.keys(obj);
|
|
for (const item10065 of keys) {
|
|
let tmp30 = obj[item10065];
|
|
let tmp31 = tmp30;
|
|
let tmp29 = item10065;
|
|
if (typeof tmp30 === "object") {
|
|
let tmp47 = tmp30;
|
|
if (null !== tmp31) {
|
|
let _Object2 = Object;
|
|
let tmp35 = tmp30;
|
|
let keys1 = Object.keys(tmp31);
|
|
let tmp37 = keys1;
|
|
let tmp38 = keys1;
|
|
for (const item10081 of keys1) {
|
|
let tmp39 = tmp30;
|
|
let tmp40 = parseValue;
|
|
tmp31[item10081] = parseValue(tmp31[item10081], merged);
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
let tmp32 = item10065;
|
|
let tmp33 = parseValue;
|
|
let tmp34 = tmp30;
|
|
obj[tmp29] = parseValue(tmp31, merged);
|
|
}
|
|
if (false === merged.sort) {
|
|
return obj;
|
|
} else {
|
|
if (true === merged.sort) {
|
|
const _Object4 = obj.Object;
|
|
const keys2 = _Object4.keys(obj);
|
|
let sorted = keys2.sort();
|
|
} else {
|
|
const _Object3 = Object;
|
|
const keys3 = Object.keys(obj);
|
|
sorted = keys3.sort(merged.sort);
|
|
}
|
|
const _Object5 = obj.Object;
|
|
obj = _Object5.create(null);
|
|
const reduced = sorted.reduce((arg0, arg1) => {
|
|
if (Boolean(keys[arg1])) {
|
|
if (typeof obj === "object") {
|
|
const _Array2 = Array;
|
|
if (!Array.isArray(obj)) {
|
|
keys = obj;
|
|
const _Array = Array;
|
|
if (Array.isArray(obj)) {
|
|
let sorted = obj.sort();
|
|
} else {
|
|
sorted = obj;
|
|
if (typeof obj === "object") {
|
|
const _Object = Object;
|
|
keys = Object.keys(obj);
|
|
const _Array3 = Array;
|
|
if (Array.isArray(keys)) {
|
|
let sorted1 = keys.sort();
|
|
} else {
|
|
sorted1 = keys;
|
|
if (typeof keys === "object") {
|
|
const _Object2 = Object;
|
|
const sorted2 = closure_1_7(Object.keys(keys)).sort((arg0, arg1) => Number(arg0) - Number(arg1));
|
|
sorted1 = sorted2.map((arg0) => keys[arg0]);
|
|
const obj3 = closure_1_7(Object.keys(keys));
|
|
}
|
|
}
|
|
keys = sorted1.sort((arg0, arg1) => Number(arg0) - Number(arg1));
|
|
const mapped = keys.map((arg0) => keys[arg0]);
|
|
}
|
|
}
|
|
arg0[arg1] = sorted;
|
|
}
|
|
return arg0;
|
|
}
|
|
}
|
|
arg0[arg1] = keys[arg1];
|
|
}, obj);
|
|
}
|
|
} else {
|
|
return obj;
|
|
}
|
|
const str5 = str.trim();
|
|
}
|
|
}
|
|
let closure_4 = Symbol("encodeFragmentIdentifier");
|
|
|
|
export const extract = function extract(arr) {
|
|
const index = arr.indexOf("#");
|
|
let substr = arr;
|
|
if (-1 !== index) {
|
|
substr = arr.slice(0, index);
|
|
}
|
|
const index1 = substr.indexOf("?");
|
|
let str = "";
|
|
if (-1 !== index1) {
|
|
str = substr.slice(index1 + 1);
|
|
}
|
|
return str;
|
|
};
|
|
export { parse };
|
|
export const stringify = (arg0, merged) => {
|
|
closure_0 = arg0;
|
|
if (arg0) {
|
|
const _Object = Object;
|
|
merged = Object.assign({ encode: true, strict: true, arrayFormat: "none", arrayFormatSeparator: "," }, merged);
|
|
validateArrayFormatSeparator(merged.arrayFormatSeparator);
|
|
function shouldFilter(item10024) {
|
|
let skipNull = merged.skipNull;
|
|
if (skipNull) {
|
|
skipNull = null == dependencyMap[item10024];
|
|
}
|
|
if (!skipNull) {
|
|
let skipEmptyString = merged.skipEmptyString;
|
|
if (skipEmptyString) {
|
|
skipEmptyString = "" === dependencyMap[item10024];
|
|
}
|
|
skipNull = skipEmptyString;
|
|
}
|
|
return skipNull;
|
|
}
|
|
closure_2 = (function encoderForArrayFormat(merged) {
|
|
closure_0 = merged;
|
|
const arrayFormat = merged.arrayFormat;
|
|
if ("index" === arrayFormat) {
|
|
return (arg0) => {
|
|
closure_0 = arg0;
|
|
return (arg0, arg1) => {
|
|
let encode = arg0;
|
|
let length = arg0.length;
|
|
let tmp = arg0;
|
|
if (undefined !== arg1) {
|
|
let items1 = lib;
|
|
if (!lib.skipNull) {
|
|
if (items1.skipEmptyString) {
|
|
tmp = encode;
|
|
}
|
|
if (null === arg1) {
|
|
const items = [];
|
|
encode = items1.encode;
|
|
if (!encode) {
|
|
items1 = [tmp24, "[", length, "]"];
|
|
length = items1.join("");
|
|
items[arraySpreadResult] = length;
|
|
let items2 = items;
|
|
} else if (items1.strict) {
|
|
let encodeURIComponentResult = lib(closure_2_2[1])(tmp24);
|
|
} else {
|
|
const _encodeURIComponent4 = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(tmp24);
|
|
}
|
|
arraySpreadResult = HermesBuiltin.arraySpread(encode, 0);
|
|
} else {
|
|
items2 = [];
|
|
if (!items1.encode) {
|
|
const items3 = [tmp35, "[", , , ];
|
|
if (!items1.encode) {
|
|
items3[2] = length;
|
|
items3[3] = "]=";
|
|
if (!items1.encode) {
|
|
items3[4] = arg1;
|
|
items2[tmp34] = items3.join("");
|
|
} else if (items1.strict) {
|
|
let encodeURIComponentResult1 = lib(closure_2_2[1])(arg1);
|
|
} else {
|
|
const _encodeURIComponent3 = encodeURIComponent;
|
|
encodeURIComponentResult1 = encodeURIComponent(arg1);
|
|
}
|
|
} else if (items1.strict) {
|
|
let encodeURIComponentResult2 = lib(closure_2_2[1])(length);
|
|
} else {
|
|
const _encodeURIComponent2 = encodeURIComponent;
|
|
encodeURIComponentResult2 = encodeURIComponent(length);
|
|
}
|
|
} else if (items1.strict) {
|
|
let encodeURIComponentResult3 = lib(closure_2_2[1])(tmp35);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult3 = encodeURIComponent(tmp35);
|
|
}
|
|
}
|
|
} else {
|
|
tmp = encode;
|
|
}
|
|
}
|
|
return tmp;
|
|
};
|
|
};
|
|
} else if ("bracket" === arrayFormat) {
|
|
return (arg0) => {
|
|
closure_0 = arg0;
|
|
return (arg0, arg1) => {
|
|
let items1 = arg0;
|
|
let tmp = arg0;
|
|
if (undefined !== arg1) {
|
|
if (!lib.skipNull) {
|
|
if (tmp25.skipEmptyString) {
|
|
tmp = items1;
|
|
}
|
|
if (null === arg1) {
|
|
const items = [];
|
|
if (!tmp25.encode) {
|
|
items1 = [tmp18, "[]"];
|
|
items[tmp17] = items1.join("");
|
|
let items2 = items;
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult = lib(closure_2_2[1])(tmp18);
|
|
} else {
|
|
const _encodeURIComponent3 = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(tmp18);
|
|
}
|
|
} else {
|
|
items2 = [];
|
|
if (!tmp25.encode) {
|
|
const items3 = [tmp30, "[]=", ];
|
|
if (!tmp25.encode) {
|
|
items3[2] = arg1;
|
|
items2[tmp29] = items3.join("");
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult1 = lib(closure_2_2[1])(arg1);
|
|
} else {
|
|
const _encodeURIComponent2 = encodeURIComponent;
|
|
encodeURIComponentResult1 = encodeURIComponent(arg1);
|
|
}
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult2 = lib(closure_2_2[1])(tmp30);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult2 = encodeURIComponent(tmp30);
|
|
}
|
|
}
|
|
} else {
|
|
tmp = items1;
|
|
}
|
|
}
|
|
return tmp;
|
|
};
|
|
};
|
|
} else if ("colon-list-separator" === arrayFormat) {
|
|
return (arg0) => {
|
|
closure_0 = arg0;
|
|
return (arg0, arg1) => {
|
|
let items1 = arg0;
|
|
let tmp = arg0;
|
|
if (undefined !== arg1) {
|
|
if (!lib.skipNull) {
|
|
if (tmp25.skipEmptyString) {
|
|
tmp = items1;
|
|
}
|
|
if (null === arg1) {
|
|
const items = [];
|
|
if (!tmp25.encode) {
|
|
items1 = [tmp18, ":list="];
|
|
items[tmp17] = items1.join("");
|
|
let items2 = items;
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult = lib(closure_2_2[1])(tmp18);
|
|
} else {
|
|
const _encodeURIComponent3 = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(tmp18);
|
|
}
|
|
} else {
|
|
items2 = [];
|
|
if (!tmp25.encode) {
|
|
const items3 = [tmp30, ":list=", ];
|
|
if (!tmp25.encode) {
|
|
items3[2] = arg1;
|
|
items2[tmp29] = items3.join("");
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult1 = lib(closure_2_2[1])(arg1);
|
|
} else {
|
|
const _encodeURIComponent2 = encodeURIComponent;
|
|
encodeURIComponentResult1 = encodeURIComponent(arg1);
|
|
}
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult2 = lib(closure_2_2[1])(tmp30);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult2 = encodeURIComponent(tmp30);
|
|
}
|
|
}
|
|
} else {
|
|
tmp = items1;
|
|
}
|
|
}
|
|
return tmp;
|
|
};
|
|
};
|
|
} else {
|
|
if ("comma" !== arrayFormat) {
|
|
if ("separator" !== arrayFormat) {
|
|
if ("bracket-separator" !== arrayFormat) {
|
|
return (arg0) => {
|
|
closure_0 = arg0;
|
|
return (arg0, arg1) => {
|
|
let encode = arg0;
|
|
let tmp = arg0;
|
|
if (undefined !== arg1) {
|
|
if (!lib.skipNull) {
|
|
if (tmp26.skipEmptyString) {
|
|
tmp = encode;
|
|
}
|
|
if (null === arg1) {
|
|
const items = [];
|
|
encode = tmp26.encode;
|
|
if (!encode) {
|
|
items[arraySpreadResult] = tmp18;
|
|
let items1 = items;
|
|
} else if (tmp26.strict) {
|
|
let encodeURIComponentResult = lib(closure_2_2[1])(tmp18);
|
|
} else {
|
|
const _encodeURIComponent3 = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(tmp18);
|
|
}
|
|
arraySpreadResult = HermesBuiltin.arraySpread(encode, 0);
|
|
} else {
|
|
items1 = [];
|
|
if (!tmp26.encode) {
|
|
const items2 = [tmp30, "=", ];
|
|
if (!tmp26.encode) {
|
|
items2[2] = arg1;
|
|
items1[tmp29] = items2.join("");
|
|
} else if (tmp26.strict) {
|
|
let encodeURIComponentResult1 = lib(closure_2_2[1])(arg1);
|
|
} else {
|
|
const _encodeURIComponent2 = encodeURIComponent;
|
|
encodeURIComponentResult1 = encodeURIComponent(arg1);
|
|
}
|
|
} else if (tmp26.strict) {
|
|
let encodeURIComponentResult2 = lib(closure_2_2[1])(tmp30);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult2 = encodeURIComponent(tmp30);
|
|
}
|
|
}
|
|
} else {
|
|
tmp = encode;
|
|
}
|
|
}
|
|
return tmp;
|
|
};
|
|
};
|
|
}
|
|
}
|
|
}
|
|
let str6 = "=";
|
|
if ("bracket-separator" === merged.arrayFormat) {
|
|
str6 = "[]=";
|
|
}
|
|
return (arg0) => {
|
|
closure_0 = arg0;
|
|
return (arg0, arg1) => {
|
|
let tmp = arg0;
|
|
if (undefined !== arg1) {
|
|
if (!lib.skipNull) {
|
|
if (tmp25.skipEmptyString) {
|
|
tmp = arg0;
|
|
}
|
|
let str3 = "";
|
|
if (null !== arg1) {
|
|
str3 = arg1;
|
|
}
|
|
if (0 === arg0.length) {
|
|
if (!tmp25.encode) {
|
|
const items = [tmp10, closure_1_1, ];
|
|
if (!tmp25.encode) {
|
|
items[2] = str3;
|
|
const items1 = [items.join("")];
|
|
let items3 = items1;
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult = lib(closure_2_2[1])(str3);
|
|
} else {
|
|
const _encodeURIComponent3 = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(str3);
|
|
}
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult1 = lib(closure_2_2[1])(tmp10);
|
|
} else {
|
|
const _encodeURIComponent2 = encodeURIComponent;
|
|
encodeURIComponentResult1 = encodeURIComponent(tmp10);
|
|
}
|
|
} else {
|
|
const items2 = [arg0, ];
|
|
if (!tmp25.encode) {
|
|
items2[1] = str3;
|
|
items3 = [items2.join(tmp25.arrayFormatSeparator)];
|
|
} else if (tmp25.strict) {
|
|
let encodeURIComponentResult2 = lib(closure_2_2[1])(str3);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult2 = encodeURIComponent(str3);
|
|
}
|
|
}
|
|
} else {
|
|
tmp = arg0;
|
|
}
|
|
}
|
|
return tmp;
|
|
};
|
|
};
|
|
}
|
|
})(merged);
|
|
const obj = {};
|
|
const _Object2 = Object;
|
|
const keys = Object.keys(arg0);
|
|
for (const item10024 of keys) {
|
|
let tmp8 = item10024;
|
|
if (!shouldFilter(item10024)) {
|
|
let tmp9 = item10024;
|
|
obj[tmp8] = arg0[tmp8];
|
|
}
|
|
continue;
|
|
}
|
|
const _Object3 = Object;
|
|
const keys1 = Object.keys(obj);
|
|
if (false !== merged.sort) {
|
|
const sorted = keys1.sort(merged.sort);
|
|
}
|
|
const mapped = keys1.map((arg0) => {
|
|
if (undefined === dependencyMap[arg0]) {
|
|
return "";
|
|
} else if (null === arr) {
|
|
if (!merged.encode) {
|
|
let text = arg0;
|
|
} else if (tmp22.strict) {
|
|
let encodeURIComponentResult = dependencyMap(1557)(arg0);
|
|
} else {
|
|
const _encodeURIComponent3 = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(arg0);
|
|
}
|
|
} else {
|
|
const _Array = Array;
|
|
if (Array.isArray(arr)) {
|
|
if (0 !== arr.length) {
|
|
const reduced = arr.reduce(dependencyMap2(arg0), []);
|
|
let joined = reduced.join("&");
|
|
}
|
|
if (!tmp13.encode) {
|
|
joined = `${arg0}[]`;
|
|
} else if (tmp13.strict) {
|
|
let encodeURIComponentResult1 = dependencyMap(1557)(arg0);
|
|
} else {
|
|
encodeURIComponentResult1 = `[]`.encodeURIComponent(arg0);
|
|
}
|
|
} else if (!merged.encode) {
|
|
if (!tmp.encode) {
|
|
text = `${arg0}=${arr}`;
|
|
} else if (tmp.strict) {
|
|
let encodeURIComponentResult2 = dependencyMap(1557)(arr);
|
|
} else {
|
|
const _encodeURIComponent2 = encodeURIComponent;
|
|
encodeURIComponentResult2 = encodeURIComponent(arr);
|
|
}
|
|
} else if (tmp.strict) {
|
|
let encodeURIComponentResult3 = dependencyMap(1557)(arg0);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult3 = encodeURIComponent(arg0);
|
|
}
|
|
}
|
|
});
|
|
const found = mapped.filter((arg0) => arg0.length > 0);
|
|
return found.join("&");
|
|
} else {
|
|
return "";
|
|
}
|
|
};
|
|
export const parseUrl = (arr) => {
|
|
const merged = Object.assign({ decode: true }, arg1);
|
|
[str, tmp5] = callback(_mod1559(arr, "#"), 2);
|
|
const tmp2 = require;
|
|
const tmp4 = callback(_mod1559(arr, "#"), 2);
|
|
let obj = { url: str.split("?")[0] || "", query: null };
|
|
const index = arr.indexOf("#");
|
|
let substr = arr;
|
|
if (-1 !== index) {
|
|
substr = arr.slice(0, index);
|
|
}
|
|
const index1 = substr.indexOf("?");
|
|
let str2 = "";
|
|
if (-1 !== index1) {
|
|
str2 = substr.slice(index1 + 1);
|
|
}
|
|
obj[1] = parse(str2, merged);
|
|
if (merged) {
|
|
if (merged.parseFragmentIdentifier) {
|
|
if (tmp5) {
|
|
let tmp11 = tmp5;
|
|
if (merged.decode) {
|
|
tmp11 = decodeComponents(tmp5);
|
|
}
|
|
obj = { fragmentIdentifier: null };
|
|
obj[0] = tmp11;
|
|
}
|
|
return Object.assign(obj, {});
|
|
}
|
|
}
|
|
};
|
|
export const stringifyUrl = (url) => {
|
|
const obj = { encode: true, strict: true };
|
|
obj[closure_4] = true;
|
|
const merged = Object.assign(obj, arg1);
|
|
url = url.url;
|
|
const index = url.indexOf("#");
|
|
let str = url;
|
|
if (-1 !== index) {
|
|
str = url.slice(0, index);
|
|
}
|
|
const json = exports.stringify(Object.assign(exports.parse(exports.extract(url.url), { sort: false }), url.query), merged);
|
|
let combined = json;
|
|
if (json) {
|
|
const _HermesInternal = HermesInternal;
|
|
combined = "?" + json;
|
|
}
|
|
const url1 = url.url;
|
|
const index1 = url1.indexOf("#");
|
|
let str2 = "";
|
|
if (-1 !== index1) {
|
|
str2 = url1.slice(index1);
|
|
}
|
|
if (!url.fragmentIdentifier) {
|
|
const _HermesInternal3 = HermesInternal;
|
|
return "" + tmp4 + combined + str2;
|
|
} else {
|
|
const fragmentIdentifier = url.fragmentIdentifier;
|
|
if (merged[tmp]) {
|
|
if (!merged.encode) {
|
|
let tmp8 = fragmentIdentifier;
|
|
} else if (merged.strict) {
|
|
let encodeURIComponentResult = _mod1557(fragmentIdentifier);
|
|
} else {
|
|
const _encodeURIComponent = encodeURIComponent;
|
|
encodeURIComponentResult = encodeURIComponent(fragmentIdentifier);
|
|
}
|
|
} else {
|
|
tmp8 = fragmentIdentifier;
|
|
}
|
|
const _HermesInternal2 = HermesInternal;
|
|
const combined1 = "#" + tmp8;
|
|
}
|
|
};
|
|
export const pick = (arg0, arg1, arg2) => {
|
|
let obj = { parseFragmentIdentifier: true };
|
|
obj[closure_4] = false;
|
|
const merged = Object.assign(obj, arg2);
|
|
const parseUrlResult = exports.parseUrl(arg0, merged);
|
|
obj = { url: parseUrlResult.url, query: _mod1560(query, arg1), fragmentIdentifier };
|
|
({ query, fragmentIdentifier } = parseUrlResult);
|
|
return exports.stringifyUrl(obj, merged);
|
|
};
|
|
export const exclude = (arg0, arg1, arg2) => {
|
|
closure_0 = arg1;
|
|
return exports.pick(arg0, Array.isArray(arg1) ? ((arg0) => !lib.includes(arg0)) : ((arg0, arg1) => !lib(arg0, arg1)), arg2);
|
|
};
|