@symbo.ls/utils 3.1.2 → 3.14.0

package/dist/esm/element.js

@@ -0,0 +1,116 @@
+import { createExtends } from "./extends.js";
+import { createKey } from "./key.js";
+import { isNode } from "./node.js";
+import { createProps } from "./props.js";
+import { HTML_TAGS } from "./tags.js";
+import { is, isFunction } from "./types.js";
+const ENV = process.env.NODE_ENV;
+const returnValueAsText = (element, parent, key) => {
+  const childExtendsTag = parent.childExtends && parent.childExtends.tag;
+  const childPropsTag = parent.childProps && parent.childProps.tag;
+  const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key;
+  return {
+    text: element,
+    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
+  };
+};
+const createBasedOnType = (element, parent, key) => {
+  if (element === void 0) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(
+        key,
+        "element is undefined in",
+        parent?.__ref?.path
+      );
+    }
+    return {};
+  }
+  if (element === null) return;
+  if (element === true) return {};
+  if (is(element)("string", "number")) {
+    return returnValueAsText(element, parent, key);
+  }
+  if (isFunction(element)) {
+    return { props: element };
+  }
+  return element;
+};
+const addRef = (element, parent) => {
+  const ref = {};
+  ref.origin = element;
+  ref.parent = parent;
+  return ref;
+};
+const createParent = (element, parent, key, options, root) => {
+  if (!parent) return root;
+  if (isNode(parent)) {
+    const parentNodeWrapper = { key: ":root", node: parent };
+    root[`${key}_parent`] = parentNodeWrapper;
+    return parentNodeWrapper;
+  }
+  return parent;
+};
+const createRoot = (element, parent) => {
+  const { __ref: ref } = element;
+  const { __ref: parentRef } = parent;
+  const hasRoot = parent && parent.key === ":root";
+  if (!ref?.root) {
+    ref.root = hasRoot ? element : parentRef?.root;
+  }
+};
+const createPath = (element, parent, key) => {
+  let { __ref: parentRef } = parent;
+  if (!parentRef) parentRef = parent.ref = {};
+  if (!parentRef.path) parentRef.path = [];
+  return parentRef.path.concat(key);
+};
+const addContext = (element, parent, key, options, root) => {
+  const forcedOptionsContext = options.context && !root.context && !element.context;
+  if (forcedOptionsContext) root.context = options.context;
+  return options.context || parent.context || root.context || element.context;
+};
+const addCaching = (element, parent, key) => {
+  const ref = addRef(element, parent);
+  element.__ref = ref;
+  if (!ref.__defineCache) ref.__defineCache = {};
+  if (!ref.__exec) ref.__exec = {};
+  if (!ref.__execProps) ref.__execProps = {};
+  if (!ref.__class) ref.__class = {};
+  if (!ref.__classNames) ref.__classNames = {};
+  if (!ref.__attr) ref.__attr = {};
+  if (!ref.__changes) ref.__changes = [];
+  if (!ref.__children) ref.__children = [];
+  ref.__extends = createExtends(element, parent, key);
+  ref.path = createPath(element, parent, key);
+  return ref;
+};
+const createElement = (passedProps, parentEl, passedKey, opts, root) => {
+  const hashed = passedProps?.__hash;
+  const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
+  if (!element) return;
+  const parent = createParent(element, parentEl, passedKey, opts, root);
+  const key = createKey(element, parent, passedKey);
+  addCaching(element, parent, key);
+  const props = createProps(element, parent, key);
+  const context = addContext(element, parent, key, opts, root);
+  const on = element.on || {};
+  return {
+    ...element,
+    key,
+    props,
+    parent,
+    context,
+    on
+  };
+};
+export {
+  addCaching,
+  addContext,
+  addRef,
+  createBasedOnType,
+  createElement,
+  createParent,
+  createPath,
+  createRoot,
+  returnValueAsText
+};

package/dist/esm/env.js

@@ -0,0 +1,23 @@
+// @preserve-env
+const NODE_ENV = process.env.NODE_ENV;
+const ENV = NODE_ENV;
+const isProduction = (env = NODE_ENV) => env === "production";
+const isTest = (env = NODE_ENV) => env === "testing" || env === "test";
+const isTesting = isTest;
+const isStaging = (env = NODE_ENV) => env === "staging";
+const isLocal = (env = NODE_ENV) => env === "local";
+const isDevelopment = (env = NODE_ENV) => env === "development" || env === "dev" || env === "local";
+const getNev = (key, env = NODE_ENV) => env[key];
+const isNotProduction = (env = NODE_ENV) => !isProduction(env);
+export {
+  ENV,
+  NODE_ENV,
+  getNev,
+  isDevelopment,
+  isLocal,
+  isNotProduction,
+  isProduction,
+  isStaging,
+  isTest,
+  isTesting
+};

package/dist/esm/events.js

@@ -0,0 +1,19 @@
+import { lowercaseFirstLetter } from "./string.js";
+import { isFunction } from "./types.js";
+function addEventFromProps(key, obj) {
+  const { props, on } = obj;
+  const eventName = lowercaseFirstLetter(key.split("on")[1]);
+  const origEvent = on[eventName];
+  const funcFromProps = props[key];
+  if (isFunction(origEvent)) {
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args);
+      if (originalEventRetunrs !== false) {
+        if (isFunction(funcFromProps)) return funcFromProps(...args);
+      }
+    };
+  } else on[eventName] = funcFromProps;
+}
+export {
+  addEventFromProps
+};

package/dist/esm/extends.js

@@ -0,0 +1,414 @@
+import { joinArrays, removeDuplicatesInArray } from "./array.js";
+import { matchesComponentNaming } from "./component.js";
+import { deepClone, exec } from "./object.js";
+import { isArray, isObject, isString } from "./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(matchesComponentNaming);
+  }
+  if (key.includes("_")) {
+    const [first] = key.split("_");
+    return [first];
+  }
+  if (key.includes(".") && !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 = 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 = isArray(elementExtend) ? elementExtend : [elementExtend];
+  const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
+  return {
+    ...element,
+    extends: 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 (!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 (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 (isArray(extend)) {
+    return extractArrayExtend(extend, stack, context, processed, nameStack, componentNameMap);
+  }
+  let currentName = parentName;
+  if (isString(extend)) {
+    currentName = extend;
+    extend = mapStringsWithContextComponents(extend, context);
+  } else if (componentNameMap && 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 = 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 (isObject(extendProp) && !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 (isObject(elementProp) && isObject(extendProp)) {
+        const nestedSourcemap = sourcemap ? sourcemap[e] = sourcemap[e] || {} : void 0;
+        const nestedPreBuilt = preBuiltSourcemap?.[e];
+        if (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 (isArray(elementProp) && isArray(extendProp)) {
+          element[e] = elementProp.concat(extendProp);
+        } else if (isArray(elementProp) && 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 (isObject(val) && !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 = 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 (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 = isArray(newExtends) ? newExtends : [newExtends];
+  return joinArrays(receivedArray, elementExtends);
+};
+const getExtendsInElement = (obj) => {
+  let result = [];
+  function traverse(o) {
+    for (const key in o) {
+      if (Object.prototype.hasOwnProperty.call(o, key)) {
+        if (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(exec(element.component, element), element);
+  }
+  if (context.defaultExtends) {
+    addExtends(context.defaultExtends, element);
+  }
+  return 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 = 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 && isObject(resolved) && 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;
+};
+export {
+  addExtend,
+  addExtends,
+  applyExtends,
+  cloneAndMergeArrayExtend,
+  concatAddExtends,
+  createElementExtends,
+  createExtends,
+  createExtendsFromKeys,
+  createExtendsStack,
+  deepExtend,
+  deepMergeExtends,
+  extendCachedRegistry,
+  extendStackRegistry,
+  extractArrayExtend,
+  finalizeExtends,
+  flattenExtend,
+  generateHash,
+  getExtendsInElement,
+  getExtendsStack,
+  getExtendsStackRegistry,
+  getHashedExtend,
+  inheritChildExtends,
+  inheritChildPropsExtends,
+  inheritRecursiveChildExtends,
+  jointStacks,
+  mapStringsWithContextComponents,
+  setHashedExtend
+};

package/dist/esm/fibonacci.js

@@ -0,0 +1,10 @@
+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];
+};
+export {
+  fibonacciNumberByIndex
+};

package/dist/esm/files.js

@@ -0,0 +1,4 @@
+const isPhoto = (format) => ["jpeg", "gif", "jpg", "png", "tiff", "woff"].includes(format);
+export {
+  isPhoto
+};

package/dist/esm/function.js

@@ -0,0 +1,94 @@
+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;
+}
+export {
+  cloneFunction,
+  debounce,
+  debounceOnContext,
+  hasHandlerPlugin,
+  isStringFunction,
+  memoize,
+  resolveHandler,
+  runPluginHook
+};

package/dist/esm/globals.js

@@ -0,0 +1,10 @@
+const global = globalThis;
+const self = globalThis;
+const window = globalThis;
+const document = window.document;
+export {
+  document,
+  global,
+  self,
+  window
+};