mirror of
https://github.com/CharaChorder/DeviceManager.git
synced 2026-01-20 17:03:42 +00:00
564 lines
16 KiB
JavaScript
564 lines
16 KiB
JavaScript
import "./chunk-2B2CG5KL.js";
|
|
|
|
// node_modules/devalue/src/utils.js
|
|
var escaped = {
|
|
"<": "\\u003C",
|
|
"\\": "\\\\",
|
|
"\b": "\\b",
|
|
"\f": "\\f",
|
|
"\n": "\\n",
|
|
"\r": "\\r",
|
|
" ": "\\t",
|
|
"\u2028": "\\u2028",
|
|
"\u2029": "\\u2029"
|
|
};
|
|
var DevalueError = class extends Error {
|
|
/**
|
|
* @param {string} message
|
|
* @param {string[]} keys
|
|
*/
|
|
constructor(message, keys) {
|
|
super(message);
|
|
this.name = "DevalueError";
|
|
this.path = keys.join("");
|
|
}
|
|
};
|
|
function is_primitive(thing) {
|
|
return Object(thing) !== thing;
|
|
}
|
|
var object_proto_names = Object.getOwnPropertyNames(
|
|
Object.prototype
|
|
).sort().join("\0");
|
|
function is_plain_object(thing) {
|
|
const proto = Object.getPrototypeOf(thing);
|
|
return proto === Object.prototype || proto === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
|
|
}
|
|
function get_type(thing) {
|
|
return Object.prototype.toString.call(thing).slice(8, -1);
|
|
}
|
|
function get_escaped_char(char) {
|
|
switch (char) {
|
|
case '"':
|
|
return '\\"';
|
|
case "<":
|
|
return "\\u003C";
|
|
case "\\":
|
|
return "\\\\";
|
|
case "\n":
|
|
return "\\n";
|
|
case "\r":
|
|
return "\\r";
|
|
case " ":
|
|
return "\\t";
|
|
case "\b":
|
|
return "\\b";
|
|
case "\f":
|
|
return "\\f";
|
|
case "\u2028":
|
|
return "\\u2028";
|
|
case "\u2029":
|
|
return "\\u2029";
|
|
default:
|
|
return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
|
|
}
|
|
}
|
|
function stringify_string(str) {
|
|
let result = "";
|
|
let last_pos = 0;
|
|
const len = str.length;
|
|
for (let i = 0; i < len; i += 1) {
|
|
const char = str[i];
|
|
const replacement = get_escaped_char(char);
|
|
if (replacement) {
|
|
result += str.slice(last_pos, i) + replacement;
|
|
last_pos = i + 1;
|
|
}
|
|
}
|
|
return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
|
|
}
|
|
|
|
// node_modules/devalue/src/uneval.js
|
|
var chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
|
|
var unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
|
|
var reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
|
|
function uneval(value, replacer) {
|
|
const counts = /* @__PURE__ */ new Map();
|
|
const keys = [];
|
|
const custom = /* @__PURE__ */ new Map();
|
|
function walk(thing) {
|
|
if (typeof thing === "function") {
|
|
throw new DevalueError(`Cannot stringify a function`, keys);
|
|
}
|
|
if (!is_primitive(thing)) {
|
|
if (counts.has(thing)) {
|
|
counts.set(thing, counts.get(thing) + 1);
|
|
return;
|
|
}
|
|
counts.set(thing, 1);
|
|
if (replacer) {
|
|
const str2 = replacer(thing);
|
|
if (typeof str2 === "string") {
|
|
custom.set(thing, str2);
|
|
return;
|
|
}
|
|
}
|
|
const type = get_type(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "BigInt":
|
|
case "String":
|
|
case "Boolean":
|
|
case "Date":
|
|
case "RegExp":
|
|
return;
|
|
case "Array":
|
|
thing.forEach((value2, i) => {
|
|
keys.push(`[${i}]`);
|
|
walk(value2);
|
|
keys.pop();
|
|
});
|
|
break;
|
|
case "Set":
|
|
Array.from(thing).forEach(walk);
|
|
break;
|
|
case "Map":
|
|
for (const [key, value2] of thing) {
|
|
keys.push(
|
|
`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`
|
|
);
|
|
walk(value2);
|
|
keys.pop();
|
|
}
|
|
break;
|
|
default:
|
|
if (!is_plain_object(thing)) {
|
|
throw new DevalueError(
|
|
`Cannot stringify arbitrary non-POJOs`,
|
|
keys
|
|
);
|
|
}
|
|
if (Object.getOwnPropertySymbols(thing).length > 0) {
|
|
throw new DevalueError(
|
|
`Cannot stringify POJOs with symbolic keys`,
|
|
keys
|
|
);
|
|
}
|
|
for (const key in thing) {
|
|
keys.push(`.${key}`);
|
|
walk(thing[key]);
|
|
keys.pop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
walk(value);
|
|
const names = /* @__PURE__ */ new Map();
|
|
Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
|
|
names.set(entry[0], get_name(i));
|
|
});
|
|
function stringify2(thing) {
|
|
if (names.has(thing)) {
|
|
return names.get(thing);
|
|
}
|
|
if (is_primitive(thing)) {
|
|
return stringify_primitive(thing);
|
|
}
|
|
if (custom.has(thing)) {
|
|
return custom.get(thing);
|
|
}
|
|
const type = get_type(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "String":
|
|
case "Boolean":
|
|
return `Object(${stringify2(thing.valueOf())})`;
|
|
case "RegExp":
|
|
return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
|
|
case "Date":
|
|
return `new Date(${thing.getTime()})`;
|
|
case "Array":
|
|
const members = (
|
|
/** @type {any[]} */
|
|
thing.map(
|
|
(v, i) => i in thing ? stringify2(v) : ""
|
|
)
|
|
);
|
|
const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
|
|
return `[${members.join(",")}${tail}]`;
|
|
case "Set":
|
|
case "Map":
|
|
return `new ${type}([${Array.from(thing).map(stringify2).join(",")}])`;
|
|
default:
|
|
const obj = `{${Object.keys(thing).map((key) => `${safe_key(key)}:${stringify2(thing[key])}`).join(",")}}`;
|
|
const proto = Object.getPrototypeOf(thing);
|
|
if (proto === null) {
|
|
return Object.keys(thing).length > 0 ? `Object.assign(Object.create(null),${obj})` : `Object.create(null)`;
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
const str = stringify2(value);
|
|
if (names.size) {
|
|
const params = [];
|
|
const statements = [];
|
|
const values = [];
|
|
names.forEach((name, thing) => {
|
|
params.push(name);
|
|
if (custom.has(thing)) {
|
|
values.push(
|
|
/** @type {string} */
|
|
custom.get(thing)
|
|
);
|
|
return;
|
|
}
|
|
if (is_primitive(thing)) {
|
|
values.push(stringify_primitive(thing));
|
|
return;
|
|
}
|
|
const type = get_type(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "String":
|
|
case "Boolean":
|
|
values.push(`Object(${stringify2(thing.valueOf())})`);
|
|
break;
|
|
case "RegExp":
|
|
values.push(thing.toString());
|
|
break;
|
|
case "Date":
|
|
values.push(`new Date(${thing.getTime()})`);
|
|
break;
|
|
case "Array":
|
|
values.push(`Array(${thing.length})`);
|
|
thing.forEach((v, i) => {
|
|
statements.push(`${name}[${i}]=${stringify2(v)}`);
|
|
});
|
|
break;
|
|
case "Set":
|
|
values.push(`new Set`);
|
|
statements.push(
|
|
`${name}.${Array.from(thing).map((v) => `add(${stringify2(v)})`).join(".")}`
|
|
);
|
|
break;
|
|
case "Map":
|
|
values.push(`new Map`);
|
|
statements.push(
|
|
`${name}.${Array.from(thing).map(([k, v]) => `set(${stringify2(k)}, ${stringify2(v)})`).join(".")}`
|
|
);
|
|
break;
|
|
default:
|
|
values.push(
|
|
Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}"
|
|
);
|
|
Object.keys(thing).forEach((key) => {
|
|
statements.push(
|
|
`${name}${safe_prop(key)}=${stringify2(thing[key])}`
|
|
);
|
|
});
|
|
}
|
|
});
|
|
statements.push(`return ${str}`);
|
|
return `(function(${params.join(",")}){${statements.join(
|
|
";"
|
|
)}}(${values.join(",")}))`;
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
function get_name(num) {
|
|
let name = "";
|
|
do {
|
|
name = chars[num % chars.length] + name;
|
|
num = ~~(num / chars.length) - 1;
|
|
} while (num >= 0);
|
|
return reserved.test(name) ? `${name}0` : name;
|
|
}
|
|
function escape_unsafe_char(c) {
|
|
return escaped[c] || c;
|
|
}
|
|
function escape_unsafe_chars(str) {
|
|
return str.replace(unsafe_chars, escape_unsafe_char);
|
|
}
|
|
function safe_key(key) {
|
|
return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
|
|
}
|
|
function safe_prop(key) {
|
|
return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
|
|
}
|
|
function stringify_primitive(thing) {
|
|
if (typeof thing === "string")
|
|
return stringify_string(thing);
|
|
if (thing === void 0)
|
|
return "void 0";
|
|
if (thing === 0 && 1 / thing < 0)
|
|
return "-0";
|
|
const str = String(thing);
|
|
if (typeof thing === "number")
|
|
return str.replace(/^(-)?0\./, "$1.");
|
|
if (typeof thing === "bigint")
|
|
return thing + "n";
|
|
return str;
|
|
}
|
|
|
|
// node_modules/devalue/src/constants.js
|
|
var UNDEFINED = -1;
|
|
var HOLE = -2;
|
|
var NAN = -3;
|
|
var POSITIVE_INFINITY = -4;
|
|
var NEGATIVE_INFINITY = -5;
|
|
var NEGATIVE_ZERO = -6;
|
|
|
|
// node_modules/devalue/src/parse.js
|
|
function parse(serialized, revivers) {
|
|
return unflatten(JSON.parse(serialized), revivers);
|
|
}
|
|
function unflatten(parsed, revivers) {
|
|
if (typeof parsed === "number")
|
|
return hydrate(parsed, true);
|
|
if (!Array.isArray(parsed) || parsed.length === 0) {
|
|
throw new Error("Invalid input");
|
|
}
|
|
const values = (
|
|
/** @type {any[]} */
|
|
parsed
|
|
);
|
|
const hydrated = Array(values.length);
|
|
function hydrate(index, standalone = false) {
|
|
if (index === UNDEFINED)
|
|
return void 0;
|
|
if (index === NAN)
|
|
return NaN;
|
|
if (index === POSITIVE_INFINITY)
|
|
return Infinity;
|
|
if (index === NEGATIVE_INFINITY)
|
|
return -Infinity;
|
|
if (index === NEGATIVE_ZERO)
|
|
return -0;
|
|
if (standalone)
|
|
throw new Error(`Invalid input`);
|
|
if (index in hydrated)
|
|
return hydrated[index];
|
|
const value = values[index];
|
|
if (!value || typeof value !== "object") {
|
|
hydrated[index] = value;
|
|
} else if (Array.isArray(value)) {
|
|
if (typeof value[0] === "string") {
|
|
const type = value[0];
|
|
const reviver = revivers == null ? void 0 : revivers[type];
|
|
if (reviver) {
|
|
return hydrated[index] = reviver(hydrate(value[1]));
|
|
}
|
|
switch (type) {
|
|
case "Date":
|
|
hydrated[index] = new Date(value[1]);
|
|
break;
|
|
case "Set":
|
|
const set = /* @__PURE__ */ new Set();
|
|
hydrated[index] = set;
|
|
for (let i = 1; i < value.length; i += 1) {
|
|
set.add(hydrate(value[i]));
|
|
}
|
|
break;
|
|
case "Map":
|
|
const map = /* @__PURE__ */ new Map();
|
|
hydrated[index] = map;
|
|
for (let i = 1; i < value.length; i += 2) {
|
|
map.set(hydrate(value[i]), hydrate(value[i + 1]));
|
|
}
|
|
break;
|
|
case "RegExp":
|
|
hydrated[index] = new RegExp(value[1], value[2]);
|
|
break;
|
|
case "Object":
|
|
hydrated[index] = Object(value[1]);
|
|
break;
|
|
case "BigInt":
|
|
hydrated[index] = BigInt(value[1]);
|
|
break;
|
|
case "null":
|
|
const obj = /* @__PURE__ */ Object.create(null);
|
|
hydrated[index] = obj;
|
|
for (let i = 1; i < value.length; i += 2) {
|
|
obj[value[i]] = hydrate(value[i + 1]);
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown type ${type}`);
|
|
}
|
|
} else {
|
|
const array = new Array(value.length);
|
|
hydrated[index] = array;
|
|
for (let i = 0; i < value.length; i += 1) {
|
|
const n = value[i];
|
|
if (n === HOLE)
|
|
continue;
|
|
array[i] = hydrate(n);
|
|
}
|
|
}
|
|
} else {
|
|
const object = {};
|
|
hydrated[index] = object;
|
|
for (const key in value) {
|
|
const n = value[key];
|
|
object[key] = hydrate(n);
|
|
}
|
|
}
|
|
return hydrated[index];
|
|
}
|
|
return hydrate(0);
|
|
}
|
|
|
|
// node_modules/devalue/src/stringify.js
|
|
function stringify(value, reducers) {
|
|
const stringified = [];
|
|
const indexes = /* @__PURE__ */ new Map();
|
|
const custom = [];
|
|
for (const key in reducers) {
|
|
custom.push({ key, fn: reducers[key] });
|
|
}
|
|
const keys = [];
|
|
let p = 0;
|
|
function flatten(thing) {
|
|
if (typeof thing === "function") {
|
|
throw new DevalueError(`Cannot stringify a function`, keys);
|
|
}
|
|
if (indexes.has(thing))
|
|
return indexes.get(thing);
|
|
if (thing === void 0)
|
|
return UNDEFINED;
|
|
if (Number.isNaN(thing))
|
|
return NAN;
|
|
if (thing === Infinity)
|
|
return POSITIVE_INFINITY;
|
|
if (thing === -Infinity)
|
|
return NEGATIVE_INFINITY;
|
|
if (thing === 0 && 1 / thing < 0)
|
|
return NEGATIVE_ZERO;
|
|
const index2 = p++;
|
|
indexes.set(thing, index2);
|
|
for (const { key, fn } of custom) {
|
|
const value2 = fn(thing);
|
|
if (value2) {
|
|
stringified[index2] = `["${key}",${flatten(value2)}]`;
|
|
return index2;
|
|
}
|
|
}
|
|
let str = "";
|
|
if (is_primitive(thing)) {
|
|
str = stringify_primitive2(thing);
|
|
} else {
|
|
const type = get_type(thing);
|
|
switch (type) {
|
|
case "Number":
|
|
case "String":
|
|
case "Boolean":
|
|
str = `["Object",${stringify_primitive2(thing)}]`;
|
|
break;
|
|
case "BigInt":
|
|
str = `["BigInt",${thing}]`;
|
|
break;
|
|
case "Date":
|
|
str = `["Date","${thing.toISOString()}"]`;
|
|
break;
|
|
case "RegExp":
|
|
const { source, flags } = thing;
|
|
str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
|
|
break;
|
|
case "Array":
|
|
str = "[";
|
|
for (let i = 0; i < thing.length; i += 1) {
|
|
if (i > 0)
|
|
str += ",";
|
|
if (i in thing) {
|
|
keys.push(`[${i}]`);
|
|
str += flatten(thing[i]);
|
|
keys.pop();
|
|
} else {
|
|
str += HOLE;
|
|
}
|
|
}
|
|
str += "]";
|
|
break;
|
|
case "Set":
|
|
str = '["Set"';
|
|
for (const value2 of thing) {
|
|
str += `,${flatten(value2)}`;
|
|
}
|
|
str += "]";
|
|
break;
|
|
case "Map":
|
|
str = '["Map"';
|
|
for (const [key, value2] of thing) {
|
|
keys.push(
|
|
`.get(${is_primitive(key) ? stringify_primitive2(key) : "..."})`
|
|
);
|
|
str += `,${flatten(key)},${flatten(value2)}`;
|
|
}
|
|
str += "]";
|
|
break;
|
|
default:
|
|
if (!is_plain_object(thing)) {
|
|
throw new DevalueError(
|
|
`Cannot stringify arbitrary non-POJOs`,
|
|
keys
|
|
);
|
|
}
|
|
if (Object.getOwnPropertySymbols(thing).length > 0) {
|
|
throw new DevalueError(
|
|
`Cannot stringify POJOs with symbolic keys`,
|
|
keys
|
|
);
|
|
}
|
|
if (Object.getPrototypeOf(thing) === null) {
|
|
str = '["null"';
|
|
for (const key in thing) {
|
|
keys.push(`.${key}`);
|
|
str += `,${stringify_string(key)},${flatten(thing[key])}`;
|
|
keys.pop();
|
|
}
|
|
str += "]";
|
|
} else {
|
|
str = "{";
|
|
let started = false;
|
|
for (const key in thing) {
|
|
if (started)
|
|
str += ",";
|
|
started = true;
|
|
keys.push(`.${key}`);
|
|
str += `${stringify_string(key)}:${flatten(thing[key])}`;
|
|
keys.pop();
|
|
}
|
|
str += "}";
|
|
}
|
|
}
|
|
}
|
|
stringified[index2] = str;
|
|
return index2;
|
|
}
|
|
const index = flatten(value);
|
|
if (index < 0)
|
|
return `${index}`;
|
|
return `[${stringified.join(",")}]`;
|
|
}
|
|
function stringify_primitive2(thing) {
|
|
const type = typeof thing;
|
|
if (type === "string")
|
|
return stringify_string(thing);
|
|
if (thing instanceof String)
|
|
return stringify_string(thing.toString());
|
|
if (thing === void 0)
|
|
return UNDEFINED.toString();
|
|
if (thing === 0 && 1 / thing < 0)
|
|
return NEGATIVE_ZERO.toString();
|
|
if (type === "bigint")
|
|
return `["BigInt","${thing}"]`;
|
|
return String(thing);
|
|
}
|
|
export {
|
|
parse,
|
|
stringify,
|
|
uneval,
|
|
unflatten
|
|
};
|
|
//# sourceMappingURL=devalue.js.map
|