@fecp/designer 5.6.5 → 5.6.8

package/lib/node_modules/es-toolkit/dist/compat/object/clone.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isPrimitive = require("../../predicate/isPrimitive.js");
+const getTag = require("../_internal/getTag.js");
+const tags = require("../_internal/tags.js");
+const isArray = require("../predicate/isArray.js");
+const isTypedArray = require("../predicate/isTypedArray.js");
+function clone(obj) {
+  if (isPrimitive.isPrimitive(obj)) return obj;
+  const tag = getTag.getTag(obj);
+  if (!isCloneableObject(obj)) return {};
+  if (isArray.isArray(obj)) {
+    const result2 = Array.from(obj);
+    if (obj.length > 0 && typeof obj[0] === "string" && Object.hasOwn(obj, "index")) {
+      result2.index = obj.index;
+      result2.input = obj.input;
+    }
+    return result2;
+  }
+  if (isTypedArray.isTypedArray(obj)) {
+    const typedArray = obj;
+    const Ctor = typedArray.constructor;
+    return new Ctor(typedArray.buffer, typedArray.byteOffset, typedArray.length);
+  }
+  if (tag === "[object ArrayBuffer]") return new ArrayBuffer(obj.byteLength);
+  if (tag === "[object DataView]") {
+    const dataView = obj;
+    const buffer = dataView.buffer;
+    const byteOffset = dataView.byteOffset;
+    const byteLength = dataView.byteLength;
+    const clonedBuffer = new ArrayBuffer(byteLength);
+    const srcView = new Uint8Array(buffer, byteOffset, byteLength);
+    new Uint8Array(clonedBuffer).set(srcView);
+    return new DataView(clonedBuffer);
+  }
+  if (tag === "[object Boolean]" || tag === "[object Number]" || tag === "[object String]") {
+    const Ctor = obj.constructor;
+    const clone2 = new Ctor(obj.valueOf());
+    if (tag === "[object String]") cloneStringObjectProperties(clone2, obj);
+    else copyOwnProperties(clone2, obj);
+    return clone2;
+  }
+  if (tag === "[object Date]") return new Date(Number(obj));
+  if (tag === "[object RegExp]") {
+    const regExp = obj;
+    const clone2 = new RegExp(regExp.source, regExp.flags);
+    clone2.lastIndex = regExp.lastIndex;
+    return clone2;
+  }
+  if (tag === "[object Symbol]") return Object(Symbol.prototype.valueOf.call(obj));
+  if (tag === "[object Map]") {
+    const map = obj;
+    const result2 = /* @__PURE__ */ new Map();
+    map.forEach((obj2, key) => {
+      result2.set(key, obj2);
+    });
+    return result2;
+  }
+  if (tag === "[object Set]") {
+    const set = obj;
+    const result2 = /* @__PURE__ */ new Set();
+    set.forEach((obj2) => {
+      result2.add(obj2);
+    });
+    return result2;
+  }
+  if (tag === "[object Arguments]") {
+    const args = obj;
+    const result2 = {};
+    copyOwnProperties(result2, args);
+    result2.length = args.length;
+    result2[Symbol.iterator] = args[Symbol.iterator];
+    return result2;
+  }
+  const result = {};
+  copyPrototype(result, obj);
+  copyOwnProperties(result, obj);
+  copySymbolProperties(result, obj);
+  return result;
+}
+function isCloneableObject(object) {
+  switch (getTag.getTag(object)) {
+    case tags.argumentsTag:
+    case tags.arrayTag:
+    case tags.arrayBufferTag:
+    case tags.dataViewTag:
+    case tags.booleanTag:
+    case tags.dateTag:
+    case tags.float32ArrayTag:
+    case tags.float64ArrayTag:
+    case tags.int8ArrayTag:
+    case tags.int16ArrayTag:
+    case tags.int32ArrayTag:
+    case tags.mapTag:
+    case tags.numberTag:
+    case tags.objectTag:
+    case tags.regexpTag:
+    case tags.setTag:
+    case tags.stringTag:
+    case tags.symbolTag:
+    case tags.uint8ArrayTag:
+    case tags.uint8ClampedArrayTag:
+    case tags.uint16ArrayTag:
+    case tags.uint32ArrayTag:
+      return true;
+    default:
+      return false;
+  }
+}
+function copyOwnProperties(target, source) {
+  for (const key in source) if (Object.hasOwn(source, key)) target[key] = source[key];
+}
+function copySymbolProperties(target, source) {
+  const symbols = Object.getOwnPropertySymbols(source);
+  for (let i = 0; i < symbols.length; i++) {
+    const symbol = symbols[i];
+    if (Object.prototype.propertyIsEnumerable.call(source, symbol)) target[symbol] = source[symbol];
+  }
+}
+function cloneStringObjectProperties(target, source) {
+  const stringLength = source.valueOf().length;
+  for (const key in source) if (Object.hasOwn(source, key) && (Number.isNaN(Number(key)) || Number(key) >= stringLength)) target[key] = source[key];
+}
+function copyPrototype(target, source) {
+  const proto = Object.getPrototypeOf(source);
+  if (proto !== null) {
+    if (typeof source.constructor === "function") Object.setPrototypeOf(target, proto);
+  }
+}
+exports.clone = clone;

package/lib/node_modules/es-toolkit/dist/compat/object/cloneDeep.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const cloneDeepWith = require("./cloneDeepWith.js");
+function cloneDeep(obj) {
+  return cloneDeepWith.cloneDeepWith(obj);
+}
+exports.cloneDeep = cloneDeep;

package/lib/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getTag = require("../_internal/getTag.js");
+const tags = require("../_internal/tags.js");
+const cloneDeepWith$1 = require("../../object/cloneDeepWith.js");
+function cloneDeepWith(obj, customizer) {
+  return cloneDeepWith$1.cloneDeepWith(obj, (value, key, object, stack) => {
+    if (typeof obj !== "object") return;
+    if (getTag.getTag(obj) === "[object Object]" && typeof obj.constructor !== "function") {
+      const result = {};
+      stack.set(obj, result);
+      cloneDeepWith$1.copyProperties(result, obj, object, stack);
+      return result;
+    }
+    switch (Object.prototype.toString.call(obj)) {
+      case tags.numberTag:
+      case tags.stringTag:
+      case tags.booleanTag: {
+        const result = new obj.constructor(obj == null ? void 0 : obj.valueOf());
+        cloneDeepWith$1.copyProperties(result, obj);
+        return result;
+      }
+      case tags.argumentsTag: {
+        const result = {};
+        cloneDeepWith$1.copyProperties(result, obj);
+        result.length = obj.length;
+        result[Symbol.iterator] = obj[Symbol.iterator];
+        return result;
+      }
+      default:
+        return;
+    }
+  });
+}
+exports.cloneDeepWith = cloneDeepWith;

package/lib/node_modules/es-toolkit/dist/compat/object/merge.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const noop = require("../../function/noop.js");
+const mergeWith = require("./mergeWith.js");
+function merge(object, ...sources) {
+  return mergeWith.mergeWith(object, ...sources, noop.noop);
+}
+exports.merge = merge;

package/lib/node_modules/es-toolkit/dist/compat/object/mergeWith.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isPrimitive = require("../../predicate/isPrimitive.js");
+const clone = require("../../object/clone.js");
+const getSymbols = require("../_internal/getSymbols.js");
+const isBuffer = require("../../predicate/isBuffer.js");
+const isUnsafeProperty = require("../../_internal/isUnsafeProperty.js");
+const isPlainObject = require("../predicate/isPlainObject.js");
+const cloneDeep = require("./cloneDeep.js");
+const isArguments = require("../predicate/isArguments.js");
+const isObjectLike = require("../predicate/isObjectLike.js");
+const isArrayLikeObject = require("../predicate/isArrayLikeObject.js");
+const isTypedArray = require("../predicate/isTypedArray.js");
+function mergeWith(object, ...otherArgs) {
+  const sources = otherArgs.slice(0, -1);
+  const merge = otherArgs[otherArgs.length - 1];
+  let result = object;
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    result = mergeWithDeep(result, source, merge, /* @__PURE__ */ new Map());
+  }
+  return result;
+}
+function mergeWithDeep(target, source, merge, stack) {
+  if (isPrimitive.isPrimitive(target)) target = Object(target);
+  if (source == null || typeof source !== "object") return target;
+  if (stack.has(source)) return clone.clone(stack.get(source));
+  stack.set(source, target);
+  if (Array.isArray(source)) {
+    source = source.slice();
+    for (let i = 0; i < source.length; i++) source[i] = source[i] ?? void 0;
+  }
+  const sourceKeys = [...Object.keys(source), ...getSymbols.getSymbols(source)];
+  for (let i = 0; i < sourceKeys.length; i++) {
+    const key = sourceKeys[i];
+    if (isUnsafeProperty.isUnsafeProperty(key)) continue;
+    let sourceValue = source[key];
+    let targetValue = target[key];
+    if (isArguments.isArguments(sourceValue)) sourceValue = { ...sourceValue };
+    if (isArguments.isArguments(targetValue)) targetValue = { ...targetValue };
+    if (isBuffer.isBuffer(sourceValue)) sourceValue = cloneDeep.cloneDeep(sourceValue);
+    if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) {
+      const cloned = [];
+      const targetKeys = Reflect.ownKeys(targetValue);
+      for (let i2 = 0; i2 < targetKeys.length; i2++) {
+        const targetKey = targetKeys[i2];
+        cloned[targetKey] = targetValue[targetKey];
+      }
+      targetValue = cloned;
+    } else if (isArrayLikeObject.isArrayLikeObject(targetValue)) {
+      const cloned = [];
+      for (let i2 = 0; i2 < targetValue.length; i2++) cloned[i2] = targetValue[i2];
+      targetValue = cloned;
+    } else targetValue = [];
+    const merged = merge(targetValue, sourceValue, key, target, source, stack);
+    if (merged !== void 0) target[key] = merged;
+    else if (Array.isArray(sourceValue)) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
+    else if (isObjectLike.isObjectLike(targetValue) && isObjectLike.isObjectLike(sourceValue) && (isPlainObject.isPlainObject(targetValue) || isPlainObject.isPlainObject(sourceValue) || isTypedArray.isTypedArray(targetValue) || isTypedArray.isTypedArray(sourceValue))) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
+    else if (targetValue == null && isPlainObject.isPlainObject(sourceValue)) target[key] = mergeWithDeep({}, sourceValue, merge, stack);
+    else if (targetValue == null && isTypedArray.isTypedArray(sourceValue)) target[key] = cloneDeep.cloneDeep(sourceValue);
+    else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+  }
+  return target;
+}
+exports.mergeWith = mergeWith;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isArguments.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getTag = require("../_internal/getTag.js");
+function isArguments(value) {
+  return value !== null && typeof value === "object" && getTag.getTag(value) === "[object Arguments]";
+}
+exports.isArguments = isArguments;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isArray.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isArray(value) {
+  return Array.isArray(value);
+}
+exports.isArray = isArray;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isLength = require("../../predicate/isLength.js");
+function isArrayLike(value) {
+  return value != null && typeof value !== "function" && isLength.isLength(value.length);
+}
+exports.isArrayLike = isArrayLike;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isArrayLike = require("./isArrayLike.js");
+const isObjectLike = require("./isObjectLike.js");
+function isArrayLikeObject(value) {
+  return isObjectLike.isObjectLike(value) && isArrayLike.isArrayLike(value);
+}
+exports.isArrayLikeObject = isArrayLikeObject;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isEmpty.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isBuffer = require("../../predicate/isBuffer.js");
+const isArrayLike = require("./isArrayLike.js");
+const isArguments = require("./isArguments.js");
+const isPrototype = require("../_internal/isPrototype.js");
+const isTypedArray = require("./isTypedArray.js");
+function isEmpty(value) {
+  if (value == null) return true;
+  if (isArrayLike.isArrayLike(value)) {
+    if (typeof value.splice !== "function" && typeof value !== "string" && !isBuffer.isBuffer(value) && !isTypedArray.isTypedArray(value) && !isArguments.isArguments(value)) return false;
+    return value.length === 0;
+  }
+  if (typeof value === "object" || typeof value === "function") {
+    if (value instanceof Map || value instanceof Set) return value.size === 0;
+    const keys = Object.keys(value);
+    if (isPrototype.isPrototype(value)) return keys.filter((x) => x !== "constructor").length === 0;
+    return keys.length === 0;
+  }
+  return true;
+}
+exports.isEmpty = isEmpty;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+exports.isObjectLike = isObjectLike;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isPlainObject(object) {
+  var _a;
+  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;
+    if (!((_a = Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)) == null ? void 0 : _a.writable)) return false;
+    return object.toString() === `[object ${tag}]`;
+  }
+  let proto = object;
+  while (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);
+  return Object.getPrototypeOf(object) === proto;
+}
+exports.isPlainObject = isPlainObject;

package/lib/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isTypedArray$1 = require("../../predicate/isTypedArray.js");
+function isTypedArray(x) {
+  return isTypedArray$1.isTypedArray(x);
+}
+exports.isTypedArray = isTypedArray;

package/lib/node_modules/es-toolkit/dist/function/noop.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function noop() {
+}
+exports.noop = noop;

package/lib/node_modules/es-toolkit/dist/object/clone.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isPrimitive = require("../predicate/isPrimitive.js");
+const isTypedArray = require("../predicate/isTypedArray.js");
+function clone(obj) {
+  if (isPrimitive.isPrimitive(obj)) return obj;
+  if (Array.isArray(obj) || isTypedArray.isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && obj instanceof SharedArrayBuffer) return obj.slice(0);
+  const prototype = Object.getPrototypeOf(obj);
+  if (prototype == null) return Object.assign(Object.create(prototype), 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) {
+    let newError;
+    if (obj instanceof AggregateError) newError = new Constructor(obj.errors, obj.message, { cause: obj.cause });
+    else newError = new Constructor(obj.message, { cause: obj.cause });
+    newError.stack = obj.stack;
+    Object.assign(newError, obj);
+    return newError;
+  }
+  if (typeof File !== "undefined" && obj instanceof File) return new Constructor([obj], obj.name, {
+    type: obj.type,
+    lastModified: obj.lastModified
+  });
+  if (typeof obj === "object") return Object.assign(Object.create(prototype), obj);
+  return obj;
+}
+exports.clone = clone;

package/lib/node_modules/es-toolkit/dist/object/cloneDeepWith.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isPrimitive = require("../predicate/isPrimitive.js");
+const isTypedArray = require("../predicate/isTypedArray.js");
+const getSymbols = require("../compat/_internal/getSymbols.js");
+const getTag = require("../compat/_internal/getTag.js");
+const tags = require("../compat/_internal/tags.js");
+const isBuffer = require("../predicate/isBuffer.js");
+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 == null ? void 0 : cloneValue(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned !== void 0) return cloned;
+  if (isPrimitive.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 (isBuffer.isBuffer(valueToClone)) return valueToClone.subarray();
+  if (isTypedArray.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 = structuredClone(valueToClone);
+    stack.set(valueToClone, result);
+    result.message = valueToClone.message;
+    result.name = valueToClone.name;
+    result.stack = valueToClone.stack;
+    result.cause = valueToClone.cause;
+    result.constructor = valueToClone.constructor;
+    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.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.getTag(object)) {
+    case tags.argumentsTag:
+    case tags.arrayTag:
+    case tags.arrayBufferTag:
+    case tags.dataViewTag:
+    case tags.booleanTag:
+    case tags.dateTag:
+    case tags.float32ArrayTag:
+    case tags.float64ArrayTag:
+    case tags.int8ArrayTag:
+    case tags.int16ArrayTag:
+    case tags.int32ArrayTag:
+    case tags.mapTag:
+    case tags.numberTag:
+    case tags.objectTag:
+    case tags.regexpTag:
+    case tags.setTag:
+    case tags.stringTag:
+    case tags.symbolTag:
+    case tags.uint8ArrayTag:
+    case tags.uint8ClampedArrayTag:
+    case tags.uint16ArrayTag:
+    case tags.uint32ArrayTag:
+      return true;
+    default:
+      return false;
+  }
+}
+exports.cloneDeepWith = cloneDeepWith;
+exports.cloneDeepWithImpl = cloneDeepWithImpl;
+exports.copyProperties = copyProperties;

package/lib/node_modules/es-toolkit/dist/predicate/isBuffer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const globalThis = require("../_internal/globalThis.js");
+function isBuffer(x) {
+  return typeof globalThis.globalThis_.Buffer !== "undefined" && globalThis.globalThis_.Buffer.isBuffer(x);
+}
+exports.isBuffer = isBuffer;

package/lib/node_modules/es-toolkit/dist/predicate/isLength.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isLength(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+exports.isLength = isLength;

package/lib/node_modules/es-toolkit/dist/predicate/isPrimitive.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+exports.isPrimitive = isPrimitive;

package/lib/node_modules/es-toolkit/dist/predicate/isTypedArray.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isTypedArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+exports.isTypedArray = isTypedArray;

package/lib/node_modules/highlight.js/es/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../../../_virtual/index.js");
+exports.HighlightJS = index.default;
+exports.default = index.default;