431 lines
14 KiB
JavaScript
431 lines
14 KiB
JavaScript
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
|
|
function getSymbols(object) {
|
|
return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
|
|
function getTag(value) {
|
|
if (value == null) {
|
|
return value === void 0 ? "[object Undefined]" : "[object Null]";
|
|
}
|
|
return Object.prototype.toString.call(value);
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
|
|
var regexpTag = "[object RegExp]";
|
|
var stringTag = "[object String]";
|
|
var numberTag = "[object Number]";
|
|
var booleanTag = "[object Boolean]";
|
|
var argumentsTag = "[object Arguments]";
|
|
var symbolTag = "[object Symbol]";
|
|
var dateTag = "[object Date]";
|
|
var mapTag = "[object Map]";
|
|
var setTag = "[object Set]";
|
|
var arrayTag = "[object Array]";
|
|
var functionTag = "[object Function]";
|
|
var arrayBufferTag = "[object ArrayBuffer]";
|
|
var objectTag = "[object Object]";
|
|
var errorTag = "[object Error]";
|
|
var dataViewTag = "[object DataView]";
|
|
var uint8ArrayTag = "[object Uint8Array]";
|
|
var uint8ClampedArrayTag = "[object Uint8ClampedArray]";
|
|
var uint16ArrayTag = "[object Uint16Array]";
|
|
var uint32ArrayTag = "[object Uint32Array]";
|
|
var bigUint64ArrayTag = "[object BigUint64Array]";
|
|
var int8ArrayTag = "[object Int8Array]";
|
|
var int16ArrayTag = "[object Int16Array]";
|
|
var int32ArrayTag = "[object Int32Array]";
|
|
var bigInt64ArrayTag = "[object BigInt64Array]";
|
|
var float32ArrayTag = "[object Float32Array]";
|
|
var float64ArrayTag = "[object Float64Array]";
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
|
|
function isPrimitive(value) {
|
|
return value == null || typeof value !== "object" && typeof value !== "function";
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
|
|
function isTypedArray(x) {
|
|
return ArrayBuffer.isView(x) && !(x instanceof DataView);
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
|
|
function cloneDeepWith(obj, cloneValue) {
|
|
return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), cloneValue);
|
|
}
|
|
function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
|
|
const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
|
|
if (cloned !== void 0) {
|
|
return cloned;
|
|
}
|
|
if (isPrimitive(valueToClone)) {
|
|
return valueToClone;
|
|
}
|
|
if (stack.has(valueToClone)) {
|
|
return stack.get(valueToClone);
|
|
}
|
|
if (Array.isArray(valueToClone)) {
|
|
const result = new Array(valueToClone.length);
|
|
stack.set(valueToClone, result);
|
|
for (let i = 0; i < valueToClone.length; i++) {
|
|
result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
|
|
}
|
|
if (Object.hasOwn(valueToClone, "index")) {
|
|
result.index = valueToClone.index;
|
|
}
|
|
if (Object.hasOwn(valueToClone, "input")) {
|
|
result.input = valueToClone.input;
|
|
}
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof Date) {
|
|
return new Date(valueToClone.getTime());
|
|
}
|
|
if (valueToClone instanceof RegExp) {
|
|
const result = new RegExp(valueToClone.source, valueToClone.flags);
|
|
result.lastIndex = valueToClone.lastIndex;
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof Map) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
stack.set(valueToClone, result);
|
|
for (const [key, value] of valueToClone) {
|
|
result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
|
|
}
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof Set) {
|
|
const result = /* @__PURE__ */ new Set();
|
|
stack.set(valueToClone, result);
|
|
for (const value of valueToClone) {
|
|
result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
|
|
}
|
|
return result;
|
|
}
|
|
if (typeof Buffer !== "undefined" && Buffer.isBuffer(valueToClone)) {
|
|
return valueToClone.subarray();
|
|
}
|
|
if (isTypedArray(valueToClone)) {
|
|
const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
|
|
stack.set(valueToClone, result);
|
|
for (let i = 0; i < valueToClone.length; i++) {
|
|
result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
|
|
}
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) {
|
|
return valueToClone.slice(0);
|
|
}
|
|
if (valueToClone instanceof DataView) {
|
|
const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (typeof File !== "undefined" && valueToClone instanceof File) {
|
|
const result = new File([valueToClone], valueToClone.name, {
|
|
type: valueToClone.type
|
|
});
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (typeof Blob !== "undefined" && valueToClone instanceof Blob) {
|
|
const result = new Blob([valueToClone], { type: valueToClone.type });
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof Error) {
|
|
const result = new valueToClone.constructor();
|
|
stack.set(valueToClone, result);
|
|
result.message = valueToClone.message;
|
|
result.name = valueToClone.name;
|
|
result.stack = valueToClone.stack;
|
|
result.cause = valueToClone.cause;
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof Boolean) {
|
|
const result = new Boolean(valueToClone.valueOf());
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof Number) {
|
|
const result = new Number(valueToClone.valueOf());
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (valueToClone instanceof String) {
|
|
const result = new String(valueToClone.valueOf());
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
|
|
const result = Object.create(Object.getPrototypeOf(valueToClone));
|
|
stack.set(valueToClone, result);
|
|
copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
|
|
return result;
|
|
}
|
|
return valueToClone;
|
|
}
|
|
function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
|
|
const keys = [...Object.keys(source), ...getSymbols(source)];
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
const descriptor = Object.getOwnPropertyDescriptor(target, key);
|
|
if (descriptor == null || descriptor.writable) {
|
|
target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
|
|
}
|
|
}
|
|
}
|
|
function isCloneableObject(object) {
|
|
switch (getTag(object)) {
|
|
case argumentsTag:
|
|
case arrayTag:
|
|
case arrayBufferTag:
|
|
case dataViewTag:
|
|
case booleanTag:
|
|
case dateTag:
|
|
case float32ArrayTag:
|
|
case float64ArrayTag:
|
|
case int8ArrayTag:
|
|
case int16ArrayTag:
|
|
case int32ArrayTag:
|
|
case mapTag:
|
|
case numberTag:
|
|
case objectTag:
|
|
case regexpTag:
|
|
case setTag:
|
|
case stringTag:
|
|
case symbolTag:
|
|
case uint8ArrayTag:
|
|
case uint8ClampedArrayTag:
|
|
case uint16ArrayTag:
|
|
case uint32ArrayTag: {
|
|
return true;
|
|
}
|
|
default: {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/cloneDeep.mjs
|
|
function cloneDeep(obj) {
|
|
return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/compat/predicate/isArray.mjs
|
|
function isArray(value) {
|
|
return Array.isArray(value);
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs
|
|
function isPlainObject(object) {
|
|
if (typeof object !== "object") {
|
|
return false;
|
|
}
|
|
if (object == null) {
|
|
return false;
|
|
}
|
|
if (Object.getPrototypeOf(object) === null) {
|
|
return true;
|
|
}
|
|
if (Object.prototype.toString.call(object) !== "[object Object]") {
|
|
const tag = object[Symbol.toStringTag];
|
|
if (tag == null) {
|
|
return false;
|
|
}
|
|
const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
|
|
if (isTagReadonly) {
|
|
return false;
|
|
}
|
|
return object.toString() === `[object ${tag}]`;
|
|
}
|
|
let proto = object;
|
|
while (Object.getPrototypeOf(proto) !== null) {
|
|
proto = Object.getPrototypeOf(proto);
|
|
}
|
|
return Object.getPrototypeOf(object) === proto;
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/findKey.mjs
|
|
function findKey(obj, predicate) {
|
|
const keys = Object.keys(obj);
|
|
return keys.find((key) => predicate(obj[key], key, obj));
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/invert.mjs
|
|
function invert(obj) {
|
|
const result = {};
|
|
const keys = Object.keys(obj);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
const value = obj[key];
|
|
result[value] = key;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/mapKeys.mjs
|
|
function mapKeys(object, getNewKey) {
|
|
const result = {};
|
|
const keys = Object.keys(object);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
const value = object[key];
|
|
result[getNewKey(value, key, object)] = value;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/mapValues.mjs
|
|
function mapValues(object, getNewValue) {
|
|
const result = {};
|
|
const keys = Object.keys(object);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
const value = object[key];
|
|
result[key] = getNewValue(value, key, object);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/clone.mjs
|
|
function clone(obj) {
|
|
if (isPrimitive(obj)) {
|
|
return obj;
|
|
}
|
|
if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && obj instanceof SharedArrayBuffer) {
|
|
return obj.slice(0);
|
|
}
|
|
const prototype = Object.getPrototypeOf(obj);
|
|
const Constructor = prototype.constructor;
|
|
if (obj instanceof Date || obj instanceof Map || obj instanceof Set) {
|
|
return new Constructor(obj);
|
|
}
|
|
if (obj instanceof RegExp) {
|
|
const newRegExp = new Constructor(obj);
|
|
newRegExp.lastIndex = obj.lastIndex;
|
|
return newRegExp;
|
|
}
|
|
if (obj instanceof DataView) {
|
|
return new Constructor(obj.buffer.slice(0));
|
|
}
|
|
if (obj instanceof Error) {
|
|
const newError = new Constructor(obj.message);
|
|
newError.stack = obj.stack;
|
|
newError.name = obj.name;
|
|
newError.cause = obj.cause;
|
|
return newError;
|
|
}
|
|
if (typeof File !== "undefined" && obj instanceof File) {
|
|
const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
|
|
return newFile;
|
|
}
|
|
if (typeof obj === "object") {
|
|
const newObject = Object.create(prototype);
|
|
return Object.assign(newObject, obj);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
|
|
function isUnsafeProperty(key) {
|
|
return key === "__proto__";
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
|
|
function isPlainObject2(value) {
|
|
if (!value || typeof value !== "object") {
|
|
return false;
|
|
}
|
|
const proto = Object.getPrototypeOf(value);
|
|
const hasObjectPrototype = proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null;
|
|
if (!hasObjectPrototype) {
|
|
return false;
|
|
}
|
|
return Object.prototype.toString.call(value) === "[object Object]";
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/string/capitalize.mjs
|
|
function capitalize(str) {
|
|
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/string/words.mjs
|
|
var CASE_SPLIT_PATTERN = new RegExp("\\p{Lu}?\\p{Ll}+|[0-9]+|\\p{Lu}+(?!\\p{Ll})|\\p{Emoji_Presentation}|\\p{Extended_Pictographic}|\\p{L}+", "gu");
|
|
function words(str) {
|
|
return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/string/camelCase.mjs
|
|
function camelCase(str) {
|
|
const words$1 = words(str);
|
|
if (words$1.length === 0) {
|
|
return "";
|
|
}
|
|
const [first, ...rest] = words$1;
|
|
return `${first.toLowerCase()}${rest.map((word) => capitalize(word)).join("")}`;
|
|
}
|
|
|
|
// ../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/string/snakeCase.mjs
|
|
function snakeCase(str) {
|
|
const words$1 = words(str);
|
|
return words$1.map((word) => word.toLowerCase()).join("_");
|
|
}
|
|
|
|
export {
|
|
isUnsafeProperty,
|
|
isPrimitive,
|
|
getSymbols,
|
|
getTag,
|
|
regexpTag,
|
|
stringTag,
|
|
numberTag,
|
|
booleanTag,
|
|
argumentsTag,
|
|
symbolTag,
|
|
dateTag,
|
|
mapTag,
|
|
setTag,
|
|
arrayTag,
|
|
functionTag,
|
|
arrayBufferTag,
|
|
objectTag,
|
|
errorTag,
|
|
dataViewTag,
|
|
uint8ArrayTag,
|
|
uint8ClampedArrayTag,
|
|
uint16ArrayTag,
|
|
uint32ArrayTag,
|
|
bigUint64ArrayTag,
|
|
int8ArrayTag,
|
|
int16ArrayTag,
|
|
int32ArrayTag,
|
|
bigInt64ArrayTag,
|
|
float32ArrayTag,
|
|
float64ArrayTag,
|
|
isTypedArray,
|
|
cloneDeepWith,
|
|
copyProperties,
|
|
cloneDeep,
|
|
isArray,
|
|
isPlainObject2 as isPlainObject,
|
|
isPlainObject as isPlainObject2,
|
|
findKey,
|
|
invert,
|
|
mapKeys,
|
|
mapValues,
|
|
clone,
|
|
capitalize,
|
|
words,
|
|
camelCase,
|
|
snakeCase
|
|
};
|
|
//# sourceMappingURL=chunk-I44M7U3D.js.map
|