494 lines
18 KiB
Plaintext
494 lines
18 KiB
Plaintext
import {
|
|
__commonJS
|
|
} from "/node_modules/.vite/deps/chunk-AUZ3RYOM.js?v=e565559a";
|
|
|
|
// node_modules/strict-uri-encode/index.js
|
|
var require_strict_uri_encode = __commonJS({
|
|
"node_modules/strict-uri-encode/index.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
|
|
}
|
|
});
|
|
|
|
// node_modules/decode-uri-component/index.js
|
|
var require_decode_uri_component = __commonJS({
|
|
"node_modules/decode-uri-component/index.js"(exports, module) {
|
|
"use strict";
|
|
var token = "%[a-f0-9]{2}";
|
|
var singleMatcher = new RegExp("(" + token + ")|([^%]+?)", "gi");
|
|
var multiMatcher = new RegExp("(" + token + ")+", "gi");
|
|
function decodeComponents(components, split) {
|
|
try {
|
|
return [decodeURIComponent(components.join(""))];
|
|
} catch (err) {
|
|
}
|
|
if (components.length === 1) {
|
|
return components;
|
|
}
|
|
split = split || 1;
|
|
var left = components.slice(0, split);
|
|
var right = components.slice(split);
|
|
return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
|
|
}
|
|
function decode(input) {
|
|
try {
|
|
return decodeURIComponent(input);
|
|
} catch (err) {
|
|
var tokens = input.match(singleMatcher) || [];
|
|
for (var i = 1; i < tokens.length; i++) {
|
|
input = decodeComponents(tokens, i).join("");
|
|
tokens = input.match(singleMatcher) || [];
|
|
}
|
|
return input;
|
|
}
|
|
}
|
|
function customDecodeURIComponent(input) {
|
|
var replaceMap = {
|
|
"%FE%FF": "��",
|
|
"%FF%FE": "��"
|
|
};
|
|
var match = multiMatcher.exec(input);
|
|
while (match) {
|
|
try {
|
|
replaceMap[match[0]] = decodeURIComponent(match[0]);
|
|
} catch (err) {
|
|
var result = decode(match[0]);
|
|
if (result !== match[0]) {
|
|
replaceMap[match[0]] = result;
|
|
}
|
|
}
|
|
match = multiMatcher.exec(input);
|
|
}
|
|
replaceMap["%C2"] = "�";
|
|
var entries = Object.keys(replaceMap);
|
|
for (var i = 0; i < entries.length; i++) {
|
|
var key = entries[i];
|
|
input = input.replace(new RegExp(key, "g"), replaceMap[key]);
|
|
}
|
|
return input;
|
|
}
|
|
module.exports = function(encodedURI) {
|
|
if (typeof encodedURI !== "string") {
|
|
throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
|
|
}
|
|
try {
|
|
encodedURI = encodedURI.replace(/\+/g, " ");
|
|
return decodeURIComponent(encodedURI);
|
|
} catch (err) {
|
|
return customDecodeURIComponent(encodedURI);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/split-on-first/index.js
|
|
var require_split_on_first = __commonJS({
|
|
"node_modules/split-on-first/index.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = (string, separator) => {
|
|
if (!(typeof string === "string" && typeof separator === "string")) {
|
|
throw new TypeError("Expected the arguments to be of type `string`");
|
|
}
|
|
if (separator === "") {
|
|
return [string];
|
|
}
|
|
const separatorIndex = string.indexOf(separator);
|
|
if (separatorIndex === -1) {
|
|
return [string];
|
|
}
|
|
return [
|
|
string.slice(0, separatorIndex),
|
|
string.slice(separatorIndex + separator.length)
|
|
];
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/filter-obj/index.js
|
|
var require_filter_obj = __commonJS({
|
|
"node_modules/filter-obj/index.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function(obj, predicate) {
|
|
var ret = {};
|
|
var keys = Object.keys(obj);
|
|
var isArr = Array.isArray(predicate);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
var val = obj[key];
|
|
if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
|
|
ret[key] = val;
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/query-string/index.js
|
|
var require_query_string = __commonJS({
|
|
"node_modules/query-string/index.js"(exports) {
|
|
var strictUriEncode = require_strict_uri_encode();
|
|
var decodeComponent = require_decode_uri_component();
|
|
var splitOnFirst = require_split_on_first();
|
|
var filterObject = require_filter_obj();
|
|
var isNullOrUndefined = (value) => value === null || value === void 0;
|
|
var encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
|
|
function encoderForArrayFormat(options) {
|
|
switch (options.arrayFormat) {
|
|
case "index":
|
|
return (key) => (result, value) => {
|
|
const index = result.length;
|
|
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
|
|
return result;
|
|
}
|
|
if (value === null) {
|
|
return [...result, [encode(key, options), "[", index, "]"].join("")];
|
|
}
|
|
return [
|
|
...result,
|
|
[encode(key, options), "[", encode(index, options), "]=", encode(value, options)].join("")
|
|
];
|
|
};
|
|
case "bracket":
|
|
return (key) => (result, value) => {
|
|
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
|
|
return result;
|
|
}
|
|
if (value === null) {
|
|
return [...result, [encode(key, options), "[]"].join("")];
|
|
}
|
|
return [...result, [encode(key, options), "[]=", encode(value, options)].join("")];
|
|
};
|
|
case "colon-list-separator":
|
|
return (key) => (result, value) => {
|
|
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
|
|
return result;
|
|
}
|
|
if (value === null) {
|
|
return [...result, [encode(key, options), ":list="].join("")];
|
|
}
|
|
return [...result, [encode(key, options), ":list=", encode(value, options)].join("")];
|
|
};
|
|
case "comma":
|
|
case "separator":
|
|
case "bracket-separator": {
|
|
const keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
|
|
return (key) => (result, value) => {
|
|
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
|
|
return result;
|
|
}
|
|
value = value === null ? "" : value;
|
|
if (result.length === 0) {
|
|
return [[encode(key, options), keyValueSep, encode(value, options)].join("")];
|
|
}
|
|
return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
|
|
};
|
|
}
|
|
default:
|
|
return (key) => (result, value) => {
|
|
if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
|
|
return result;
|
|
}
|
|
if (value === null) {
|
|
return [...result, encode(key, options)];
|
|
}
|
|
return [...result, [encode(key, options), "=", encode(value, options)].join("")];
|
|
};
|
|
}
|
|
}
|
|
function parserForArrayFormat(options) {
|
|
let result;
|
|
switch (options.arrayFormat) {
|
|
case "index":
|
|
return (key, value, accumulator) => {
|
|
result = /\[(\d*)\]$/.exec(key);
|
|
key = key.replace(/\[\d*\]$/, "");
|
|
if (!result) {
|
|
accumulator[key] = value;
|
|
return;
|
|
}
|
|
if (accumulator[key] === void 0) {
|
|
accumulator[key] = {};
|
|
}
|
|
accumulator[key][result[1]] = value;
|
|
};
|
|
case "bracket":
|
|
return (key, value, accumulator) => {
|
|
result = /(\[\])$/.exec(key);
|
|
key = key.replace(/\[\]$/, "");
|
|
if (!result) {
|
|
accumulator[key] = value;
|
|
return;
|
|
}
|
|
if (accumulator[key] === void 0) {
|
|
accumulator[key] = [value];
|
|
return;
|
|
}
|
|
accumulator[key] = [].concat(accumulator[key], value);
|
|
};
|
|
case "colon-list-separator":
|
|
return (key, value, accumulator) => {
|
|
result = /(:list)$/.exec(key);
|
|
key = key.replace(/:list$/, "");
|
|
if (!result) {
|
|
accumulator[key] = value;
|
|
return;
|
|
}
|
|
if (accumulator[key] === void 0) {
|
|
accumulator[key] = [value];
|
|
return;
|
|
}
|
|
accumulator[key] = [].concat(accumulator[key], value);
|
|
};
|
|
case "comma":
|
|
case "separator":
|
|
return (key, value, accumulator) => {
|
|
const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
|
|
const isEncodedArray = typeof value === "string" && !isArray && decode(value, options).includes(options.arrayFormatSeparator);
|
|
value = isEncodedArray ? decode(value, options) : value;
|
|
const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode(item, options)) : value === null ? value : decode(value, options);
|
|
accumulator[key] = newValue;
|
|
};
|
|
case "bracket-separator":
|
|
return (key, value, accumulator) => {
|
|
const isArray = /(\[\])$/.test(key);
|
|
key = key.replace(/\[\]$/, "");
|
|
if (!isArray) {
|
|
accumulator[key] = value ? decode(value, options) : value;
|
|
return;
|
|
}
|
|
const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map((item) => decode(item, options));
|
|
if (accumulator[key] === void 0) {
|
|
accumulator[key] = arrayValue;
|
|
return;
|
|
}
|
|
accumulator[key] = [].concat(accumulator[key], arrayValue);
|
|
};
|
|
default:
|
|
return (key, value, accumulator) => {
|
|
if (accumulator[key] === void 0) {
|
|
accumulator[key] = value;
|
|
return;
|
|
}
|
|
accumulator[key] = [].concat(accumulator[key], value);
|
|
};
|
|
}
|
|
}
|
|
function validateArrayFormatSeparator(value) {
|
|
if (typeof value !== "string" || value.length !== 1) {
|
|
throw new TypeError("arrayFormatSeparator must be single character string");
|
|
}
|
|
}
|
|
function encode(value, options) {
|
|
if (options.encode) {
|
|
return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
|
|
}
|
|
return value;
|
|
}
|
|
function decode(value, options) {
|
|
if (options.decode) {
|
|
return decodeComponent(value);
|
|
}
|
|
return value;
|
|
}
|
|
function keysSorter(input) {
|
|
if (Array.isArray(input)) {
|
|
return input.sort();
|
|
}
|
|
if (typeof input === "object") {
|
|
return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
|
|
}
|
|
return input;
|
|
}
|
|
function removeHash(input) {
|
|
const hashStart = input.indexOf("#");
|
|
if (hashStart !== -1) {
|
|
input = input.slice(0, hashStart);
|
|
}
|
|
return input;
|
|
}
|
|
function getHash(url) {
|
|
let hash = "";
|
|
const hashStart = url.indexOf("#");
|
|
if (hashStart !== -1) {
|
|
hash = url.slice(hashStart);
|
|
}
|
|
return hash;
|
|
}
|
|
function extract(input) {
|
|
input = removeHash(input);
|
|
const queryStart = input.indexOf("?");
|
|
if (queryStart === -1) {
|
|
return "";
|
|
}
|
|
return input.slice(queryStart + 1);
|
|
}
|
|
function parseValue(value, options) {
|
|
if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
|
|
value = Number(value);
|
|
} else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
|
|
value = value.toLowerCase() === "true";
|
|
}
|
|
return value;
|
|
}
|
|
function parse(query, options) {
|
|
options = Object.assign({
|
|
decode: true,
|
|
sort: true,
|
|
arrayFormat: "none",
|
|
arrayFormatSeparator: ",",
|
|
parseNumbers: false,
|
|
parseBooleans: false
|
|
}, options);
|
|
validateArrayFormatSeparator(options.arrayFormatSeparator);
|
|
const formatter = parserForArrayFormat(options);
|
|
const ret = /* @__PURE__ */ Object.create(null);
|
|
if (typeof query !== "string") {
|
|
return ret;
|
|
}
|
|
query = query.trim().replace(/^[?#&]/, "");
|
|
if (!query) {
|
|
return ret;
|
|
}
|
|
for (const param of query.split("&")) {
|
|
if (param === "") {
|
|
continue;
|
|
}
|
|
let [key, value] = splitOnFirst(options.decode ? param.replace(/\+/g, " ") : param, "=");
|
|
value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode(value, options);
|
|
formatter(decode(key, options), value, ret);
|
|
}
|
|
for (const key of Object.keys(ret)) {
|
|
const value = ret[key];
|
|
if (typeof value === "object" && value !== null) {
|
|
for (const k of Object.keys(value)) {
|
|
value[k] = parseValue(value[k], options);
|
|
}
|
|
} else {
|
|
ret[key] = parseValue(value, options);
|
|
}
|
|
}
|
|
if (options.sort === false) {
|
|
return ret;
|
|
}
|
|
return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
|
|
const value = ret[key];
|
|
if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
|
|
result[key] = keysSorter(value);
|
|
} else {
|
|
result[key] = value;
|
|
}
|
|
return result;
|
|
}, /* @__PURE__ */ Object.create(null));
|
|
}
|
|
exports.extract = extract;
|
|
exports.parse = parse;
|
|
exports.stringify = (object, options) => {
|
|
if (!object) {
|
|
return "";
|
|
}
|
|
options = Object.assign({
|
|
encode: true,
|
|
strict: true,
|
|
arrayFormat: "none",
|
|
arrayFormatSeparator: ","
|
|
}, options);
|
|
validateArrayFormatSeparator(options.arrayFormatSeparator);
|
|
const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
|
|
const formatter = encoderForArrayFormat(options);
|
|
const objectCopy = {};
|
|
for (const key of Object.keys(object)) {
|
|
if (!shouldFilter(key)) {
|
|
objectCopy[key] = object[key];
|
|
}
|
|
}
|
|
const keys = Object.keys(objectCopy);
|
|
if (options.sort !== false) {
|
|
keys.sort(options.sort);
|
|
}
|
|
return keys.map((key) => {
|
|
const value = object[key];
|
|
if (value === void 0) {
|
|
return "";
|
|
}
|
|
if (value === null) {
|
|
return encode(key, options);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
if (value.length === 0 && options.arrayFormat === "bracket-separator") {
|
|
return encode(key, options) + "[]";
|
|
}
|
|
return value.reduce(formatter(key), []).join("&");
|
|
}
|
|
return encode(key, options) + "=" + encode(value, options);
|
|
}).filter((x) => x.length > 0).join("&");
|
|
};
|
|
exports.parseUrl = (url, options) => {
|
|
options = Object.assign({
|
|
decode: true
|
|
}, options);
|
|
const [url_, hash] = splitOnFirst(url, "#");
|
|
return Object.assign(
|
|
{
|
|
url: url_.split("?")[0] || "",
|
|
query: parse(extract(url), options)
|
|
},
|
|
options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode(hash, options) } : {}
|
|
);
|
|
};
|
|
exports.stringifyUrl = (object, options) => {
|
|
options = Object.assign({
|
|
encode: true,
|
|
strict: true,
|
|
[encodeFragmentIdentifier]: true
|
|
}, options);
|
|
const url = removeHash(object.url).split("?")[0] || "";
|
|
const queryFromUrl = exports.extract(object.url);
|
|
const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
|
|
const query = Object.assign(parsedQueryFromUrl, object.query);
|
|
let queryString = exports.stringify(query, options);
|
|
if (queryString) {
|
|
queryString = `?${queryString}`;
|
|
}
|
|
let hash = getHash(object.url);
|
|
if (object.fragmentIdentifier) {
|
|
hash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
|
|
}
|
|
return `${url}${queryString}${hash}`;
|
|
};
|
|
exports.pick = (input, filter, options) => {
|
|
options = Object.assign({
|
|
parseFragmentIdentifier: true,
|
|
[encodeFragmentIdentifier]: false
|
|
}, options);
|
|
const { url, query, fragmentIdentifier } = exports.parseUrl(input, options);
|
|
return exports.stringifyUrl({
|
|
url,
|
|
query: filterObject(query, filter),
|
|
fragmentIdentifier
|
|
}, options);
|
|
};
|
|
exports.exclude = (input, filter, options) => {
|
|
const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
|
|
return exports.pick(input, exclusionFilter, options);
|
|
};
|
|
}
|
|
});
|
|
export default require_query_string();
|
|
//# sourceMappingURL=query-string.js.map
|
|
3 ɂt e�^�e�^�F�O1gՐ� v O^partitionKey=%28http%2Clocalhost%2C5173%29,:http://localhost:5173/node_modules/.vite/deps/query-string.js?v=e565559a strongly-framed 1 request-method GET response-head HTTP/1.1 200 OK
|
|
Access-Control-Allow-Origin: *
|
|
Content-Type: application/javascript
|
|
Cache-Control: max-age=31536000,immutable
|
|
Etag: W/"43c4-MxI2NUTkbbNKbRJdi5zAv8LrAOQ"
|
|
Date: Fri, 15 Mar 2024 14:37:23 GMT
|
|
Content-Length: 17348
|
|
original-response-headers Access-Control-Allow-Origin: *
|
|
Content-Type: application/javascript
|
|
Cache-Control: max-age=31536000,immutable
|
|
Etag: W/"43c4-MxI2NUTkbbNKbRJdi5zAv8LrAOQ"
|
|
Date: Fri, 15 Mar 2024 14:37:23 GMT
|
|
Connection: keep-alive
|
|
Keep-Alive: timeout=5
|
|
Content-Length: 17348
|
|
ctid 2 uncompressed-len 0 net-response-time-onstart 38 net-response-time-onstop 38 C� |