barebones docker | pocketbase | hono | svelte
This commit is contained in:
JCEEE
@@ -0,0 +1,450 @@
|
||||
//#region ../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/constants.js
|
||||
var MAX_ARRAY_LEN = 2 ** 32 - 1;
|
||||
var MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
|
||||
//#endregion
|
||||
//#region ../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/utils.js
|
||||
/** @type {Record<string, string>} */
|
||||
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
|
||||
* @param {any} [value] - The value that failed to be serialized
|
||||
* @param {any} [root] - The root value being serialized
|
||||
*/
|
||||
constructor(message, keys, value, root) {
|
||||
super(message);
|
||||
this.name = "DevalueError";
|
||||
this.path = keys.join("");
|
||||
this.value = value;
|
||||
this.root = root;
|
||||
}
|
||||
};
|
||||
/** @param {any} thing */
|
||||
function is_primitive(thing) {
|
||||
return thing === null || typeof thing !== "object" && typeof thing !== "function";
|
||||
}
|
||||
var object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
|
||||
/** @param {any} thing */
|
||||
function is_plain_object(thing) {
|
||||
const proto = Object.getPrototypeOf(thing);
|
||||
return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
|
||||
}
|
||||
/** @param {any} thing */
|
||||
function get_type(thing) {
|
||||
return Object.prototype.toString.call(thing).slice(8, -1);
|
||||
}
|
||||
/** @param {string} char */
|
||||
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")}` : "";
|
||||
}
|
||||
}
|
||||
/** @param {string} str */
|
||||
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)}"`;
|
||||
}
|
||||
/** @param {Record<string | symbol, any>} object */
|
||||
function enumerable_symbols(object) {
|
||||
return Object.getOwnPropertySymbols(object).filter((symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable);
|
||||
}
|
||||
var is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
|
||||
/** @param {string} key */
|
||||
function stringify_key(key) {
|
||||
return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
|
||||
}
|
||||
/** @param {number} n */
|
||||
function is_valid_array_index(n) {
|
||||
if (!Number.isInteger(n)) return false;
|
||||
if (n < 0) return false;
|
||||
if (n > MAX_ARRAY_INDEX) return false;
|
||||
return true;
|
||||
}
|
||||
/** @param {number} n */
|
||||
function is_valid_array_len(n) {
|
||||
if (!Number.isInteger(n)) return false;
|
||||
if (n < 0) return false;
|
||||
if (n > MAX_ARRAY_LEN) return false;
|
||||
return true;
|
||||
}
|
||||
/** @param {string} s */
|
||||
function is_valid_array_index_string(s) {
|
||||
if (s.length === 0) return false;
|
||||
if (s.length > 1 && s.charCodeAt(0) === 48) return false;
|
||||
for (let i = 0; i < s.length; i++) {
|
||||
const c = s.charCodeAt(i);
|
||||
if (c < 48 || c > 57) return false;
|
||||
}
|
||||
return is_valid_array_index(+s);
|
||||
}
|
||||
/**
|
||||
* Finds the populated indices of an array.
|
||||
* @param {unknown[]} array
|
||||
*/
|
||||
function valid_array_indices(array) {
|
||||
const keys = Object.keys(array);
|
||||
for (var i = keys.length - 1; i >= 0; i--) if (is_valid_array_index_string(keys[i])) break;
|
||||
keys.length = i + 1;
|
||||
return keys;
|
||||
}
|
||||
//#endregion
|
||||
//#region ../node_modules/.pnpm/devalue@5.8.1/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)$/;
|
||||
/**
|
||||
* Turn a value into the JavaScript that creates an equivalent value
|
||||
* @param {any} value
|
||||
* @param {(value: any, uneval: (value: any) => string) => string | void} [replacer]
|
||||
*/
|
||||
function uneval(value, replacer) {
|
||||
const counts = /* @__PURE__ */ new Map();
|
||||
/** @type {string[]} */
|
||||
const keys = [];
|
||||
const custom = /* @__PURE__ */ new Map();
|
||||
/** @param {any} thing */
|
||||
function walk(thing) {
|
||||
if (!is_primitive(thing)) {
|
||||
if (counts.has(thing)) {
|
||||
counts.set(thing, counts.get(thing) + 1);
|
||||
return;
|
||||
}
|
||||
counts.set(thing, 1);
|
||||
if (replacer) {
|
||||
const str = replacer(thing, (value) => uneval(value, replacer));
|
||||
if (typeof str === "string") {
|
||||
custom.set(thing, str);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (typeof thing === "function") throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
|
||||
switch (get_type(thing)) {
|
||||
case "Number":
|
||||
case "BigInt":
|
||||
case "String":
|
||||
case "Boolean":
|
||||
case "Date":
|
||||
case "RegExp":
|
||||
case "URL":
|
||||
case "URLSearchParams": return;
|
||||
case "Array":
|
||||
/** @type {any[]} */ thing.forEach((value, i) => {
|
||||
keys.push(`[${i}]`);
|
||||
walk(value);
|
||||
keys.pop();
|
||||
});
|
||||
break;
|
||||
case "Set":
|
||||
Array.from(thing).forEach(walk);
|
||||
break;
|
||||
case "Map":
|
||||
for (const [key, value] of thing) {
|
||||
keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
|
||||
walk(value);
|
||||
keys.pop();
|
||||
}
|
||||
break;
|
||||
case "Int8Array":
|
||||
case "Uint8Array":
|
||||
case "Uint8ClampedArray":
|
||||
case "Int16Array":
|
||||
case "Uint16Array":
|
||||
case "Float16Array":
|
||||
case "Int32Array":
|
||||
case "Uint32Array":
|
||||
case "Float32Array":
|
||||
case "Float64Array":
|
||||
case "BigInt64Array":
|
||||
case "BigUint64Array":
|
||||
case "DataView":
|
||||
walk(thing.buffer);
|
||||
return;
|
||||
case "ArrayBuffer": return;
|
||||
case "Temporal.Duration":
|
||||
case "Temporal.Instant":
|
||||
case "Temporal.PlainDate":
|
||||
case "Temporal.PlainTime":
|
||||
case "Temporal.PlainDateTime":
|
||||
case "Temporal.PlainMonthDay":
|
||||
case "Temporal.PlainYearMonth":
|
||||
case "Temporal.ZonedDateTime": return;
|
||||
default:
|
||||
if (!is_plain_object(thing)) throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
|
||||
if (enumerable_symbols(thing).length > 0) throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
|
||||
for (const key of Object.keys(thing)) {
|
||||
if (key === "__proto__") throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
|
||||
keys.push(stringify_key(key));
|
||||
walk(thing[key]);
|
||||
keys.pop();
|
||||
}
|
||||
}
|
||||
} else if (typeof thing === "symbol") throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
|
||||
}
|
||||
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));
|
||||
});
|
||||
/**
|
||||
* @param {any} thing
|
||||
* @returns {string}
|
||||
*/
|
||||
function stringify(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":
|
||||
case "BigInt": return `Object(${stringify(thing.valueOf())})`;
|
||||
case "RegExp":
|
||||
const { source, flags } = thing;
|
||||
return flags ? `new RegExp(${stringify_string(source)},"${flags}")` : `new RegExp(${stringify_string(source)})`;
|
||||
case "Date": return `new Date(${thing.getTime()})`;
|
||||
case "URL": return `new URL(${stringify_string(thing.toString())})`;
|
||||
case "URLSearchParams": return `new URLSearchParams(${stringify_string(thing.toString())})`;
|
||||
case "Array": {
|
||||
let has_holes = false;
|
||||
let result = "[";
|
||||
for (let i = 0; i < thing.length; i += 1) {
|
||||
if (i > 0) result += ",";
|
||||
if (Object.hasOwn(thing, i)) result += stringify(thing[i]);
|
||||
else if (!has_holes) {
|
||||
const populated_keys = valid_array_indices(thing);
|
||||
const population = populated_keys.length;
|
||||
const d = String(thing.length).length;
|
||||
if (thing.length + 2 > 25 + d + population * (d + 2)) {
|
||||
const entries = populated_keys.map((k) => `${k}:${stringify(thing[k])}`).join(",");
|
||||
return `Object.assign(Array(${thing.length}),{${entries}})`;
|
||||
}
|
||||
has_holes = true;
|
||||
i -= 1;
|
||||
}
|
||||
}
|
||||
const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
|
||||
return result + tail + "]";
|
||||
}
|
||||
case "Set":
|
||||
case "Map": return `new ${type}([${Array.from(thing).map(stringify).join(",")}])`;
|
||||
case "Int8Array":
|
||||
case "Uint8Array":
|
||||
case "Uint8ClampedArray":
|
||||
case "Int16Array":
|
||||
case "Uint16Array":
|
||||
case "Float16Array":
|
||||
case "Int32Array":
|
||||
case "Uint32Array":
|
||||
case "Float32Array":
|
||||
case "Float64Array":
|
||||
case "BigInt64Array":
|
||||
case "BigUint64Array": {
|
||||
let str = `new ${type}`;
|
||||
if (!names.has(thing.buffer)) {
|
||||
const array = new thing.constructor(thing.buffer);
|
||||
str += `([${array}])`;
|
||||
} else str += `(${stringify(thing.buffer)})`;
|
||||
if (thing.byteLength !== thing.buffer.byteLength) {
|
||||
const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
|
||||
const end = start + thing.length;
|
||||
str += `.subarray(${start},${end})`;
|
||||
}
|
||||
return str;
|
||||
}
|
||||
case "DataView": {
|
||||
let str = `new DataView`;
|
||||
if (!names.has(thing.buffer)) str += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
|
||||
else str += `(${stringify(thing.buffer)}`;
|
||||
if (thing.byteLength !== thing.buffer.byteLength) str += `,${thing.startOffset},${thing.byteLength}`;
|
||||
return str + ")";
|
||||
}
|
||||
case "ArrayBuffer": return `new Uint8Array([${new Uint8Array(thing).toString()}]).buffer`;
|
||||
case "Temporal.Duration":
|
||||
case "Temporal.Instant":
|
||||
case "Temporal.PlainDate":
|
||||
case "Temporal.PlainTime":
|
||||
case "Temporal.PlainDateTime":
|
||||
case "Temporal.PlainMonthDay":
|
||||
case "Temporal.PlainYearMonth":
|
||||
case "Temporal.ZonedDateTime": return `${type}.from(${stringify_string(thing.toString())})`;
|
||||
default:
|
||||
const keys = Object.keys(thing);
|
||||
const obj = keys.map((key) => `${safe_key(key)}:${stringify(thing[key])}`).join(",");
|
||||
if (Object.getPrototypeOf(thing) === null) return keys.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
|
||||
return `{${obj}}`;
|
||||
}
|
||||
}
|
||||
const str = stringify(value);
|
||||
if (names.size) {
|
||||
/** @type {string[]} */
|
||||
const params = [];
|
||||
/** @type {string[]} */
|
||||
const statements = [];
|
||||
/** @type {string[]} */
|
||||
const values = [];
|
||||
names.forEach((name, thing) => {
|
||||
params.push(name);
|
||||
if (custom.has(thing)) {
|
||||
values.push(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":
|
||||
case "BigInt":
|
||||
values.push(`Object(${stringify(thing.valueOf())})`);
|
||||
break;
|
||||
case "RegExp":
|
||||
const { source, flags } = thing;
|
||||
const regexp = flags ? `new RegExp(${stringify_string(source)},"${flags}")` : `new RegExp(${stringify_string(source)})`;
|
||||
values.push(regexp);
|
||||
break;
|
||||
case "Date":
|
||||
values.push(`new Date(${thing.getTime()})`);
|
||||
break;
|
||||
case "URL":
|
||||
values.push(`new URL(${stringify_string(thing.toString())})`);
|
||||
break;
|
||||
case "URLSearchParams":
|
||||
values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
|
||||
break;
|
||||
case "Array":
|
||||
values.push(`Array(${thing.length})`);
|
||||
/** @type {any[]} */ thing.forEach((v, i) => {
|
||||
statements.push(`${name}[${i}]=${stringify(v)}`);
|
||||
});
|
||||
break;
|
||||
case "Set":
|
||||
values.push(`new Set`);
|
||||
statements.push(`${name}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`);
|
||||
break;
|
||||
case "Map":
|
||||
values.push(`new Map`);
|
||||
statements.push(`${name}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`);
|
||||
break;
|
||||
case "Int8Array":
|
||||
case "Uint8Array":
|
||||
case "Uint8ClampedArray":
|
||||
case "Int16Array":
|
||||
case "Uint16Array":
|
||||
case "Float16Array":
|
||||
case "Int32Array":
|
||||
case "Uint32Array":
|
||||
case "Float32Array":
|
||||
case "Float64Array":
|
||||
case "BigInt64Array":
|
||||
case "BigUint64Array": {
|
||||
let str = `new ${type}`;
|
||||
if (!names.has(thing.buffer)) {
|
||||
const array = new thing.constructor(thing.buffer);
|
||||
str += `([${array}])`;
|
||||
} else str += `(${stringify(thing.buffer)})`;
|
||||
if (thing.byteLength !== thing.buffer.byteLength) {
|
||||
const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
|
||||
const end = start + thing.length;
|
||||
str += `.subarray(${start},${end})`;
|
||||
}
|
||||
values.push(`{}`);
|
||||
statements.push(`${name}=${str}`);
|
||||
break;
|
||||
}
|
||||
case "DataView": {
|
||||
let str = `new DataView`;
|
||||
if (!names.has(thing.buffer)) str += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
|
||||
else str += `(${stringify(thing.buffer)}`;
|
||||
if (thing.byteLength !== thing.buffer.byteLength) str += `,${thing.byteOffset},${thing.byteLength}`;
|
||||
str += ")";
|
||||
values.push(`{}`);
|
||||
statements.push(`${name}=${str}`);
|
||||
break;
|
||||
}
|
||||
case "ArrayBuffer":
|
||||
values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
|
||||
break;
|
||||
default:
|
||||
values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
|
||||
Object.keys(thing).forEach((key) => {
|
||||
statements.push(`${name}${safe_prop(key)}=${stringify(thing[key])}`);
|
||||
});
|
||||
}
|
||||
});
|
||||
statements.push(`return ${str}`);
|
||||
return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
|
||||
} else return str;
|
||||
}
|
||||
/** @param {number} num */
|
||||
function get_name(num) {
|
||||
let name = "";
|
||||
do {
|
||||
name = chars[num % 54] + name;
|
||||
num = ~~(num / 54) - 1;
|
||||
} while (num >= 0);
|
||||
return reserved.test(name) ? `${name}0` : name;
|
||||
}
|
||||
/** @param {string} c */
|
||||
function escape_unsafe_char(c) {
|
||||
return escaped[c] || c;
|
||||
}
|
||||
/** @param {string} str */
|
||||
function escape_unsafe_chars(str) {
|
||||
return str.replace(unsafe_chars, escape_unsafe_char);
|
||||
}
|
||||
/** @param {string} key */
|
||||
function safe_key(key) {
|
||||
return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
|
||||
}
|
||||
/** @param {string} key */
|
||||
function safe_prop(key) {
|
||||
return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
|
||||
}
|
||||
/** @param {any} thing */
|
||||
function stringify_primitive(thing) {
|
||||
const type = typeof thing;
|
||||
if (type === "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 (type === "number") return str.replace(/^(-)?0\./, "$1.");
|
||||
if (type === "bigint") return thing + "n";
|
||||
return str;
|
||||
}
|
||||
//#endregion
|
||||
export { is_plain_object as a, is_valid_array_len as c, valid_array_indices as d, MAX_ARRAY_INDEX as f, get_type as i, stringify_key as l, DevalueError as n, is_primitive as o, enumerable_symbols as r, is_valid_array_index as s, uneval as t, stringify_string as u };
|
||||
Reference in New Issue
Block a user