@symbo.ls/utils 3.14.0 → 3.14.2

package/dist/cjs/extends.js

@@ -1,434 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var extends_exports = {};
-__export(extends_exports, {
-  addExtend: () => addExtend,
-  addExtends: () => addExtends,
-  applyExtends: () => applyExtends,
-  cloneAndMergeArrayExtend: () => cloneAndMergeArrayExtend,
-  concatAddExtends: () => concatAddExtends,
-  createElementExtends: () => createElementExtends,
-  createExtends: () => createExtends,
-  createExtendsFromKeys: () => createExtendsFromKeys,
-  createExtendsStack: () => createExtendsStack,
-  deepExtend: () => deepExtend,
-  deepMergeExtends: () => deepMergeExtends,
-  extendCachedRegistry: () => extendCachedRegistry,
-  extendStackRegistry: () => extendStackRegistry,
-  extractArrayExtend: () => extractArrayExtend,
-  finalizeExtends: () => finalizeExtends,
-  flattenExtend: () => flattenExtend,
-  generateHash: () => generateHash,
-  getExtendsInElement: () => getExtendsInElement,
-  getExtendsStack: () => getExtendsStack,
-  getExtendsStackRegistry: () => getExtendsStackRegistry,
-  getHashedExtend: () => getHashedExtend,
-  inheritChildExtends: () => inheritChildExtends,
-  inheritChildPropsExtends: () => inheritChildPropsExtends,
-  inheritRecursiveChildExtends: () => inheritRecursiveChildExtends,
-  jointStacks: () => jointStacks,
-  mapStringsWithContextComponents: () => mapStringsWithContextComponents,
-  setHashedExtend: () => setHashedExtend
-});
-module.exports = __toCommonJS(extends_exports);
-var import_array = require("./array.js");
-var import_component = require("./component.js");
-var import_object = require("./object.js");
-var import_types = require("./types.js");
-const ENV = process.env.NODE_ENV;
-const isSourcemapEnabled = (options) => options.sourcemap !== false && ENV !== "production";
-const createExtendsFromKeys = (key) => {
-  if (key.includes("+")) {
-    return key.split("+").filter(import_component.matchesComponentNaming);
-  }
-  if (key.includes("_")) {
-    const [first] = key.split("_");
-    return [first];
-  }
-  if (key.includes(".") && !(0, import_component.matchesComponentNaming)(key.split(".")[1])) {
-    const [first] = key.split(".");
-    return [first];
-  }
-  return [key];
-};
-const createExtends = (element, parent, key) => {
-  let __extends = [];
-  const keyExtends = createExtendsFromKeys(key);
-  if (keyExtends) __extends = [...keyExtends];
-  const elementExtends = element.extends;
-  if (elementExtends) {
-    __extends = (0, import_types.isArray)(elementExtends) ? [...__extends, ...elementExtends] : [...__extends, elementExtends];
-  }
-  return __extends;
-};
-const addExtends = (newExtends, element) => {
-  const { __ref: ref } = element;
-  let { __extends } = ref;
-  if (!newExtends) return __extends;
-  const variant = element.variant;
-  const context = element.context;
-  if (variant && context?.components && !Array.isArray(newExtends) && typeof newExtends === "string") {
-    const variantKey = `${newExtends}.${variant}`;
-    if (context.components[variantKey]) {
-      newExtends = variantKey;
-    }
-  }
-  if (!__extends.includes(newExtends)) {
-    __extends = Array.isArray(newExtends) ? [...__extends, ...newExtends] : [...__extends, newExtends];
-    ref.__extends = __extends;
-  }
-  return __extends;
-};
-const concatAddExtends = (newExtend, element) => {
-  if (!newExtend) return element;
-  const { extends: elementExtend } = element;
-  const originalArray = (0, import_types.isArray)(elementExtend) ? elementExtend : [elementExtend];
-  const receivedArray = (0, import_types.isArray)(newExtend) ? newExtend : [newExtend];
-  return {
-    ...element,
-    extends: (0, import_array.joinArrays)(receivedArray, originalArray)
-  };
-};
-const generateHash = () => Math.random().toString(36).substring(2);
-const extendStackRegistry = {};
-const extendCachedRegistry = {};
-const getHashedExtend = (extend) => {
-  return extendStackRegistry[extend.__hash];
-};
-const setHashedExtend = (extend, stack) => {
-  const hash = generateHash();
-  if (!(0, import_types.isString)(extend)) {
-    extend.__hash = hash;
-  }
-  if (hash !== "__proto__" && hash !== "constructor" && hash !== "prototype") {
-    extendStackRegistry[hash] = stack;
-  }
-  return stack;
-};
-const getExtendsStackRegistry = (extend, stack) => {
-  if (extend.__hash) {
-    return stack.concat(getHashedExtend(extend));
-  }
-  return setHashedExtend(extend, stack);
-};
-const extractArrayExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set(), nameStack, componentNameMap) => {
-  for (const each of extend) {
-    if ((0, import_types.isArray)(each)) {
-      extractArrayExtend(each, stack, context, processed, nameStack, componentNameMap);
-    } else {
-      flattenExtend(each, stack, context, processed, nameStack, void 0, componentNameMap);
-    }
-  }
-  return stack;
-};
-const deepExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set(), nameStack, currentName, componentNameMap) => {
-  const extendOflattenExtend = extend.extends;
-  const cleanExtend = { ...extend };
-  delete cleanExtend.extends;
-  let hasKeys = false;
-  for (const _k in cleanExtend) {
-    hasKeys = true;
-    break;
-  }
-  if (hasKeys) {
-    stack.push(cleanExtend);
-    if (nameStack) nameStack.push(currentName);
-  }
-  if (extendOflattenExtend) {
-    flattenExtend(extendOflattenExtend, stack, context, processed, nameStack, currentName, componentNameMap);
-  }
-  return stack;
-};
-const flattenExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set(), nameStack, parentName, componentNameMap) => {
-  if (!extend) return stack;
-  if (processed.has(extend)) return stack;
-  if ((0, import_types.isArray)(extend)) {
-    return extractArrayExtend(extend, stack, context, processed, nameStack, componentNameMap);
-  }
-  let currentName = parentName;
-  if ((0, import_types.isString)(extend)) {
-    currentName = extend;
-    extend = mapStringsWithContextComponents(extend, context);
-  } else if (componentNameMap && (0, import_types.isObject)(extend) && componentNameMap.has(extend)) {
-    currentName = componentNameMap.get(extend);
-  }
-  processed.add(extend);
-  if (extend?.extends) {
-    deepExtend(extend, stack, context, processed, nameStack, currentName, componentNameMap);
-  } else if (extend) {
-    stack.push(extend);
-    if (nameStack) nameStack.push(currentName);
-  }
-  return stack;
-};
-const MERGE_EXTENDS_SKIP = /* @__PURE__ */ new Set([
-  "parent",
-  "node",
-  "__ref",
-  "__proto__",
-  "extends",
-  "childExtends",
-  "childExtendsRecursive"
-]);
-const deepMergeExtends = (element, extend, sourcemap, sourceName, preBuiltSourcemap) => {
-  extend = (0, import_object.deepClone)(extend);
-  for (const e in extend) {
-    if (MERGE_EXTENDS_SKIP.has(e)) continue;
-    const elementProp = element[e];
-    const extendProp = extend[e];
-    if (extendProp === void 0) continue;
-    if (Object.prototype.hasOwnProperty.call(extend, e) && e !== "__proto__" && e !== "constructor" && e !== "prototype") {
-      if (elementProp === void 0) {
-        element[e] = extendProp;
-        if (sourcemap && sourceName) {
-          if ((0, import_types.isObject)(extendProp) && !(0, import_types.isArray)(extendProp)) {
-            sourcemap[e] = sourcemap[e] || {};
-            trackSourcemapDeep(sourcemap[e], extendProp, sourceName);
-          } else {
-            sourcemap[e] = sourceName;
-          }
-        } else if (sourcemap && preBuiltSourcemap?.[e]) {
-          sourcemap[e] = preBuiltSourcemap[e];
-        }
-      } else if ((0, import_types.isObject)(elementProp) && (0, import_types.isObject)(extendProp)) {
-        const nestedSourcemap = sourcemap ? sourcemap[e] = sourcemap[e] || {} : void 0;
-        const nestedPreBuilt = preBuiltSourcemap?.[e];
-        if ((0, import_component.matchesComponentNaming)(e)) {
-          element[e] = deepMergeExtends(elementProp, extendProp, nestedSourcemap, sourceName, nestedPreBuilt);
-        } else {
-          deepMergeExtends(elementProp, extendProp, nestedSourcemap, sourceName, nestedPreBuilt);
-        }
-      }
-      if (e === "extends" || e === "childExtends" || e === "childExtendsRecursive") {
-        if ((0, import_types.isArray)(elementProp) && (0, import_types.isArray)(extendProp)) {
-          element[e] = elementProp.concat(extendProp);
-        } else if ((0, import_types.isArray)(elementProp) && (0, import_types.isObject)(extendProp)) {
-          const obj = deepMergeExtends({}, elementProp);
-          element[e] = deepMergeExtends(obj, extendProp);
-        }
-      }
-    }
-  }
-  return element;
-};
-const trackSourcemapDeep = (sourcemap, obj, sourceName, seen) => {
-  if (!seen) seen = /* @__PURE__ */ new WeakSet();
-  if (seen.has(obj)) return;
-  seen.add(obj);
-  for (const key in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-    const val = obj[key];
-    if ((0, import_types.isObject)(val) && !(0, import_types.isArray)(val)) {
-      sourcemap[key] = sourcemap[key] || {};
-      trackSourcemapDeep(sourcemap[key], val, sourceName, seen);
-    } else {
-      sourcemap[key] = sourceName;
-    }
-  }
-};
-const cloneAndMergeArrayExtend = (stack, sourcemap, extendNames) => {
-  return stack.reduce((acc, current, i) => {
-    const cloned = (0, import_object.deepClone)(current);
-    const sourceName = extendNames ? extendNames[i] : void 0;
-    return deepMergeExtends(acc, cloned, sourcemap, sourceName);
-  }, {});
-};
-const mapStringsWithContextComponents = (extend, context, options = {}, variant) => {
-  const COMPONENTS = context?.components || options.components;
-  const PAGES = context?.pages || options.pages;
-  if ((0, import_types.isString)(extend)) {
-    const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
-    const pageExists = PAGES && extend.charCodeAt(0) === 47 && PAGES[extend];
-    if (componentExists) return componentExists;
-    else if (pageExists) return pageExists;
-    else {
-      if (options.verbose && (ENV === "test" || ENV === "development")) {
-        console.warn("Extend is string but component was not found:", extend);
-      }
-      return;
-    }
-  }
-  return extend;
-};
-const jointStacks = (extendStack, childExtendsStack) => {
-  return [].concat(extendStack.slice(0, 1)).concat(childExtendsStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendsStack.slice(1));
-};
-const getExtendsStack = (extend, context, nameStack, componentNameMap) => {
-  if (!extend) return [];
-  if (extend.__hash) return getHashedExtend(extend) || [];
-  const processed = /* @__PURE__ */ new Set();
-  const stack = flattenExtend(extend, [], context, processed, nameStack, void 0, componentNameMap);
-  if (nameStack) return stack;
-  return getExtendsStackRegistry(extend, stack);
-};
-const addExtend = (newExtends, elementExtends) => {
-  if (!newExtends) return elementExtends;
-  const receivedArray = (0, import_types.isArray)(newExtends) ? newExtends : [newExtends];
-  return (0, import_array.joinArrays)(receivedArray, elementExtends);
-};
-const getExtendsInElement = (obj) => {
-  let result = [];
-  function traverse(o) {
-    for (const key in o) {
-      if (Object.prototype.hasOwnProperty.call(o, key)) {
-        if ((0, import_component.matchesComponentNaming)(key)) {
-          result.push(key);
-        }
-        if (key === "extends") {
-          if (typeof o[key] === "string") {
-            result.push(o[key]);
-          } else if (Array.isArray(o[key])) {
-            result = result.concat(o[key]);
-          }
-        }
-        if (typeof o[key] === "object" && o[key] !== null) {
-          traverse(o[key]);
-        }
-      }
-    }
-  }
-  traverse(obj);
-  return result;
-};
-const createElementExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element;
-  const context = element.context || parent.context;
-  const variant = element.variant;
-  if (element.extends) {
-    if (Array.isArray(element.extends) && element.extends.length > 0) {
-      const [firstExtend, ...restExtends] = element.extends;
-      if (typeof firstExtend === "string" && variant && context?.components) {
-        const variantKey = `${firstExtend}.${variant}`;
-        if (context.components[variantKey]) {
-          addExtends([variantKey, ...restExtends], element);
-        } else {
-          addExtends(element.extends, element);
-        }
-      } else {
-        addExtends(element.extends, element);
-      }
-    } else if (typeof element.extends === "string" && variant && context?.components) {
-      const variantKey = `${element.extends}.${variant}`;
-      if (context.components[variantKey]) {
-        addExtends(variantKey, element);
-      } else {
-        addExtends(element.extends, element);
-      }
-    } else {
-      addExtends(element.extends, element);
-    }
-  }
-  inheritChildPropsExtends(element, parent, options);
-  inheritChildExtends(element, parent, options);
-  inheritRecursiveChildExtends(element, parent, options);
-  if (element.component) {
-    addExtends((0, import_object.exec)(element.component, element), element);
-  }
-  if (context.defaultExtends) {
-    addExtends(context.defaultExtends, element);
-  }
-  return (0, import_array.removeDuplicatesInArray)(ref.__extends);
-};
-const inheritChildPropsExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element;
-  const ignoreChildExtends = options.ignoreChildExtends || element.ignoreChildExtends;
-  if (!ignoreChildExtends) {
-    if (parent.childProps?.extends) {
-      addExtends(parent.childProps.extends, element);
-    }
-  }
-  return ref.__extends;
-};
-const inheritChildExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element;
-  const ignoreChildExtends = options.ignoreChildExtends || element.ignoreChildExtends;
-  const childExtends = parent.childExtends;
-  if (!ignoreChildExtends && childExtends) {
-    addExtends(childExtends, element);
-  }
-  return ref.__extends;
-};
-const inheritRecursiveChildExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element;
-  const childExtendsRecursive = parent.childExtendsRecursive;
-  const ignoreChildExtendsRecursive = options.ignoreChildExtendsRecursive || element.ignoreChildExtendsRecursive;
-  const isText = element.key === "__text";
-  if (childExtendsRecursive && !isText && !ignoreChildExtendsRecursive) {
-    addExtends(childExtendsRecursive, element);
-  }
-  return ref.__extends;
-};
-const createExtendsStack = (element, parent, options = {}) => {
-  const { __ref: ref } = element;
-  const context = element.context || parent.context;
-  const variant = element.variant;
-  const sourcemap = isSourcemapEnabled(options);
-  const originalExtendNames = sourcemap ? [...ref.__extends] : null;
-  const __extends = (0, import_array.removeDuplicatesInArray)(
-    ref.__extends.map((val, i) => {
-      return mapStringsWithContextComponents(
-        val,
-        context,
-        options,
-        i === 0 && variant
-      );
-    })
-  );
-  if (sourcemap) {
-    const componentNameMap = /* @__PURE__ */ new WeakMap();
-    for (let i = 0; i < __extends.length; i++) {
-      const resolved = __extends[i];
-      const originalName = originalExtendNames[i];
-      if (resolved && (0, import_types.isObject)(resolved) && (0, import_types.isString)(originalName)) {
-        componentNameMap.set(resolved, originalName);
-      }
-    }
-    const nameStack = [];
-    const stack = getExtendsStack(__extends, context, nameStack, componentNameMap);
-    ref.__extendsStack = stack;
-    ref.__extendsNames = nameStack;
-  } else {
-    const stack = getExtendsStack(__extends, context);
-    ref.__extendsStack = stack;
-  }
-  return ref.__extendsStack;
-};
-const finalizeExtends = (element, parent, options = {}) => {
-  const { __ref: ref } = element;
-  const { __extendsStack } = ref;
-  if (isSourcemapEnabled(options)) {
-    const sourcemapAcc = {};
-    const extendNames = ref.__extendsNames || [];
-    const flattenExtends = cloneAndMergeArrayExtend(__extendsStack, sourcemapAcc, extendNames);
-    const appliedSourcemap = {};
-    deepMergeExtends(element, flattenExtends, appliedSourcemap, void 0, sourcemapAcc);
-    ref.__sourcemap = appliedSourcemap;
-  } else {
-    const flattenExtends = cloneAndMergeArrayExtend(__extendsStack);
-    deepMergeExtends(element, flattenExtends);
-  }
-  return element;
-};
-const applyExtends = (element, parent, options = {}) => {
-  createElementExtends(element, parent, options);
-  createExtendsStack(element, parent, options);
-  finalizeExtends(element, parent, options);
-  return element;
-};

package/dist/cjs/fibonacci.js

@@ -1,30 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var fibonacci_exports = {};
-__export(fibonacci_exports, {
-  fibonacciNumberByIndex: () => fibonacciNumberByIndex
-});
-module.exports = __toCommonJS(fibonacci_exports);
-const fibonacciNumberByIndex = function fibonacciNumberByIndex2(n) {
-  const fib = [0, 1];
-  for (let i = 2; i <= n; i++) {
-    fib[i] = fib[i - 1] + fib[i - 2];
-  }
-  return fib[n];
-};

package/dist/cjs/files.js

@@ -1,24 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var files_exports = {};
-__export(files_exports, {
-  isPhoto: () => isPhoto
-});
-module.exports = __toCommonJS(files_exports);
-const isPhoto = (format) => ["jpeg", "gif", "jpg", "png", "tiff", "woff"].includes(format);

package/dist/cjs/function.js

@@ -1,114 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var function_exports = {};
-__export(function_exports, {
-  cloneFunction: () => cloneFunction,
-  debounce: () => debounce,
-  debounceOnContext: () => debounceOnContext,
-  hasHandlerPlugin: () => hasHandlerPlugin,
-  isStringFunction: () => isStringFunction,
-  memoize: () => memoize,
-  resolveHandler: () => resolveHandler,
-  runPluginHook: () => runPluginHook
-});
-module.exports = __toCommonJS(function_exports);
-function debounce(func, wait, immediate) {
-  let timeout;
-  return function() {
-    const context = this;
-    const args = arguments;
-    const later = function() {
-      timeout = null;
-      if (!immediate) func.apply(context, args);
-    };
-    const callNow = immediate && !timeout;
-    clearTimeout(timeout);
-    timeout = setTimeout(later, wait);
-    if (callNow) func.apply(context, args);
-  };
-}
-const debounceOnContext = (element, func, timeout = 300) => {
-  let timer;
-  return (...args) => {
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      func.apply(element, args);
-    }, timeout);
-  };
-};
-const memoize = (fn) => {
-  const cache = {};
-  return (...args) => {
-    const n = args[0];
-    if (n in cache) {
-      return cache[n];
-    } else {
-      const result = fn(n);
-      cache[n] = result;
-      return result;
-    }
-  };
-};
-const RE_STRING_FUNCTION = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
-const isStringFunction = (inputString) => {
-  return RE_STRING_FUNCTION.test(inputString);
-};
-const hasHandlerPlugin = (ctx) => {
-  const plugins = ctx?.plugins;
-  if (!plugins || !plugins.length) return false;
-  for (const plugin of plugins) {
-    if (plugin.resolveHandler) return true;
-  }
-  return false;
-};
-const resolveHandler = (handler, element) => {
-  if (typeof handler === "function") return handler;
-  const plugins = element?.context?.plugins;
-  if (!plugins) return handler;
-  for (const plugin of plugins) {
-    if (plugin.resolveHandler) {
-      const resolved = plugin.resolveHandler(handler, element);
-      if (typeof resolved === "function") return resolved;
-    }
-  }
-  return handler;
-};
-const runPluginHook = (hookName, element, ...args) => {
-  const plugins = element?.context?.plugins;
-  if (!plugins) return false;
-  let handled = false;
-  for (const plugin of plugins) {
-    if (typeof plugin[hookName] === "function") {
-      plugin[hookName](element, ...args);
-      handled = true;
-    }
-  }
-  return handled;
-};
-function cloneFunction(fn, win = window) {
-  const temp = function() {
-    return fn.apply(win, arguments);
-  };
-  for (const key in fn) {
-    if (Object.prototype.hasOwnProperty.call(fn, key)) {
-      temp[key] = fn[key];
-    }
-  }
-  return temp;
-}

package/dist/cjs/globals.js

@@ -1,30 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var globals_exports = {};
-__export(globals_exports, {
-  document: () => document,
-  global: () => global,
-  self: () => self,
-  window: () => window
-});
-module.exports = __toCommonJS(globals_exports);
-const global = globalThis;
-const self = globalThis;
-const window = globalThis;
-const document = window.document;

package/dist/cjs/if.js

@@ -1,48 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var if_exports = {};
-__export(if_exports, {
-  createIfConditionFlag: () => createIfConditionFlag
-});
-module.exports = __toCommonJS(if_exports);
-var import_types = require("./types.js");
-var import_object = require("./object.js");
-const createIfConditionFlag = (element, parent) => {
-  const { __ref: ref } = element;
-  const ifVal = element.if;
-  if ((0, import_types.isFunction)(ifVal)) {
-    let result;
-    try {
-      result = ifVal(element, element.state, element.context);
-    } catch (e) {
-      if (typeof console !== "undefined") console.warn("[DOMQL] if condition error:", e);
-      delete ref.__if;
-      return;
-    }
-    if (!result) {
-      delete ref.__if;
-    } else ref.__if = true;
-  } else if (ifVal != null && typeof ifVal === "object") {
-    const result = (0, import_object.exec)(ifVal, element);
-    if (!result) delete ref.__if;
-    else ref.__if = true;
-  } else {
-    ref.__if = true;
-  }
-};