@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/array.js

@@ -0,0 +1,168 @@
+"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 array_exports = {};
+__export(array_exports, {
+  addItemAfterEveryElement: () => addItemAfterEveryElement,
+  addProtoToArray: () => addProtoToArray,
+  arrayContainsOtherArray: () => arrayContainsOtherArray,
+  arraysEqual: () => arraysEqual,
+  checkIfStringIsInArray: () => checkIfStringIsInArray,
+  cutArrayAfterValue: () => cutArrayAfterValue,
+  cutArrayBeforeValue: () => cutArrayBeforeValue,
+  filterArrays: () => filterArrays,
+  filterArraysFast: () => filterArraysFast,
+  getFrequencyInArray: () => getFrequencyInArray,
+  joinArrays: () => joinArrays,
+  removeDuplicatesInArray: () => removeDuplicatesInArray,
+  removeFromArray: () => removeFromArray,
+  removeValueFromArray: () => removeValueFromArray,
+  removeValueFromArrayAll: () => removeValueFromArrayAll,
+  reorderArrayByValues: () => reorderArrayByValues,
+  swapItemsInArray: () => swapItemsInArray,
+  unstackArrayOfObjects: () => unstackArrayOfObjects
+});
+module.exports = __toCommonJS(array_exports);
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+const arrayContainsOtherArray = (arr1, arr2) => {
+  return arr2.every((val) => arr1.includes(val));
+};
+const getFrequencyInArray = (arr, value) => {
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === value) count++;
+  }
+  return count;
+};
+const removeFromArray = (arr, index) => {
+  if ((0, import_types.isString)(index)) index = parseInt(index);
+  if ((0, import_types.isNumber)(index)) {
+    if (index < 0 || index >= arr.length || isNaN(index)) {
+      throw new Error("Invalid index");
+    }
+    arr.splice(index, 1);
+  } else {
+    throw new Error("Invalid index");
+  }
+  return arr;
+};
+const swapItemsInArray = (arr, i, j) => {
+  if (i < 0 || j < 0 || i >= arr.length || j >= arr.length) return;
+  [arr[i], arr[j]] = [arr[j], arr[i]];
+};
+const joinArrays = (...arrays) => {
+  return [].concat(...arrays);
+};
+const unstackArrayOfObjects = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => (0, import_object.deepMerge)(a, (0, import_object.deepClone)(c, { exclude }), exclude),
+    {}
+  );
+};
+const cutArrayBeforeValue = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index !== -1) {
+    return arr.slice(0, index);
+  }
+  return arr;
+};
+const cutArrayAfterValue = (arr, value) => {
+  if (!(0, import_types.isArray)(arr)) return;
+  const index = arr.indexOf(value);
+  if (index !== -1) {
+    return arr.slice(index + 1);
+  }
+  return arr;
+};
+const removeValueFromArray = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index > -1) {
+    const newArray = [...arr];
+    newArray.splice(index, 1);
+    return newArray;
+  }
+  return arr;
+};
+const removeValueFromArrayAll = (arr, value) => {
+  return arr.filter((item) => item !== value);
+};
+const addItemAfterEveryElement = (array, item) => {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(item);
+    }
+  }
+  return result;
+};
+const reorderArrayByValues = (array, valueToMove, insertBeforeValue) => {
+  const newArray = [...array];
+  const indexToMove = newArray.indexOf(valueToMove);
+  const indexToInsertBefore = newArray.indexOf(insertBeforeValue);
+  if (indexToMove !== -1 && indexToInsertBefore !== -1) {
+    const removedItem = newArray.splice(indexToMove, 1)[0];
+    const insertIndex = indexToInsertBefore < indexToMove ? indexToInsertBefore : indexToInsertBefore + 1;
+    newArray.splice(insertIndex, 0, removedItem);
+  }
+  return newArray;
+};
+const arraysEqual = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const filterArrays = (sourceArr, excludeArr) => {
+  return sourceArr.filter((item) => !excludeArr.includes(item));
+};
+const filterArraysFast = (sourceArr, excludeArr) => {
+  const excludeSet = new Set(excludeArr);
+  return sourceArr.filter((item) => !excludeSet.has(item));
+};
+const checkIfStringIsInArray = (string, arr) => {
+  if (!string) return 0;
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (string.includes(arr[i])) count++;
+  }
+  return count;
+};
+const removeDuplicatesInArray = (arr) => {
+  if (!(0, import_types.isArray)(arr)) return arr;
+  return [...new Set(arr)];
+};
+const addProtoToArray = (state, proto) => {
+  for (const key in proto) {
+    Object.defineProperty(state, key, {
+      value: proto[key],
+      enumerable: false,
+      // Set this to true if you want the method to appear in for...in loops
+      configurable: true,
+      // Set this to true if you want to allow redefining/removing the property later
+      writable: true
+      // Set this to true if you want to allow changing the function later
+    });
+  }
+};

package/dist/cjs/browser.js

@@ -16,8 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/browser.js
 var browser_exports = {};
 __export(browser_exports, {
   toggleFullscreen: () => toggleFullscreen

package/dist/cjs/cache.js

@@ -0,0 +1,26 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  OPTIONS: () => OPTIONS,
+  cache: () => cache
+});
+module.exports = __toCommonJS(cache_exports);
+const cache = {};
+const OPTIONS = {};

package/dist/cjs/cdn.js

@@ -0,0 +1,85 @@
+"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 cdn_exports = {};
+__export(cdn_exports, {
+  CDN_PROVIDERS: () => CDN_PROVIDERS,
+  PACKAGE_MANAGER_TO_CDN: () => PACKAGE_MANAGER_TO_CDN,
+  getCDNUrl: () => getCDNUrl,
+  getCdnProviderFromConfig: () => getCdnProviderFromConfig,
+  getImportMapScript: () => getImportMapScript
+});
+module.exports = __toCommonJS(cdn_exports);
+function onlyDotsAndNumbers(str) {
+  return /^[0-9.]+$/.test(str) && str !== "";
+}
+const CDN_PROVIDERS = {
+  skypack: {
+    url: "https://cdn.skypack.dev",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.skypack.url}/${pkg}${version !== "latest" ? `@${version}` : ""}`
+  },
+  esmsh: {
+    url: "https://esm.sh",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.esmsh.url}/${pkg}${version !== "latest" ? `@${version}` : ""}`
+  },
+  unpkg: {
+    url: "https://unpkg.com",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.unpkg.url}/${pkg}${version !== "latest" ? `@${version}` : ""}?module`
+  },
+  jsdelivr: {
+    url: "https://cdn.jsdelivr.net/npm",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.jsdelivr.url}/${pkg}${version !== "latest" ? `@${version}` : ""}/+esm`
+  },
+  symbols: {
+    url: "https://pkg.symbo.ls",
+    formatUrl: (pkg, version) => {
+      if (pkg.split("/").length > 2 || !onlyDotsAndNumbers(version)) {
+        return `${CDN_PROVIDERS.symbols.url}/${pkg}`;
+      }
+      return `${CDN_PROVIDERS.symbols.url}/${pkg}/${version}.js`;
+    }
+  }
+};
+const PACKAGE_MANAGER_TO_CDN = {
+  "esm.sh": "esmsh",
+  "unpkg": "unpkg",
+  "skypack": "skypack",
+  "jsdelivr": "jsdelivr",
+  "pkg.symbo.ls": "symbols"
+};
+const getCdnProviderFromConfig = (symbolsConfig = {}) => {
+  const { packageManager } = symbolsConfig;
+  return PACKAGE_MANAGER_TO_CDN[packageManager] || null;
+};
+const getCDNUrl = (packageName, version = "latest", provider = "esmsh") => {
+  const cdnConfig = CDN_PROVIDERS[provider] || CDN_PROVIDERS.esmsh;
+  return cdnConfig.formatUrl(packageName, version);
+};
+const getImportMapScript = (data, defaultProvider = "skypack") => {
+  const dependencies = data.dependencies || {};
+  const keys = Object.keys(dependencies);
+  if (!keys.length) return "";
+  const imports = {};
+  for (const pkgName of keys) {
+    const version = dependencies[pkgName] || "latest";
+    imports[pkgName] = getCDNUrl(pkgName, version, defaultProvider);
+  }
+  return `<script type="importmap">{
+    "imports": ${JSON.stringify(imports, null, 2)}
+  }<\/script>`;
+};

package/dist/cjs/component.js

@@ -0,0 +1,45 @@
+"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 component_exports = {};
+__export(component_exports, {
+  getCapitalCaseKeys: () => getCapitalCaseKeys,
+  getSpreadChildren: () => getSpreadChildren,
+  isContextComponent: () => isContextComponent,
+  matchesComponentNaming: () => matchesComponentNaming
+});
+module.exports = __toCommonJS(component_exports);
+var import_extends = require("./extends.js");
+var import_types = require("./types.js");
+const matchesComponentNaming = (key) => {
+  if (!(0, import_types.isString)(key) || !key.length) return false;
+  const code = key.charCodeAt(0);
+  return code >= 65 && code <= 90;
+};
+function getCapitalCaseKeys(obj) {
+  return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
+}
+function getSpreadChildren(obj) {
+  return Object.keys(obj).filter((key) => /^\d+$/.test(key));
+}
+function isContextComponent(element, parent, passedKey) {
+  const { context } = parent || {};
+  const [extendsKey] = (0, import_extends.createExtendsFromKeys)(passedKey);
+  const key = passedKey || extendsKey;
+  return context?.components?.[key] || context?.pages?.[key];
+}

package/dist/cjs/cookie.js

@@ -0,0 +1,75 @@
+"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 cookie_exports = {};
+__export(cookie_exports, {
+  getCookie: () => getCookie,
+  getLocalStorage: () => getLocalStorage,
+  isMobile: () => isMobile,
+  removeCookie: () => removeCookie,
+  setCookie: () => setCookie,
+  setLocalStorage: () => setLocalStorage
+});
+module.exports = __toCommonJS(cookie_exports);
+var import_types = require("./types.js");
+var import_globals = require("./globals.js");
+const isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+const setCookie = (cname, cvalue, exdays = 365) => {
+  if ((0, import_types.isUndefined)(import_globals.document) || (0, import_types.isUndefined)(import_globals.document.cookie)) return;
+  const d = /* @__PURE__ */ new Date();
+  d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1e3);
+  const expires = `expires=${d.toUTCString()}`;
+  import_globals.document.cookie = `${cname}=${cvalue};${expires};path=/`;
+};
+const getCookie = (cname) => {
+  if ((0, import_types.isUndefined)(import_globals.document) || (0, import_types.isUndefined)(import_globals.document.cookie)) return;
+  const name = `${cname}=`;
+  const decodedCookie = decodeURIComponent(import_globals.document.cookie);
+  const ca = decodedCookie.split(";");
+  for (let i = 0; i < ca.length; i++) {
+    let c = ca[i];
+    while (c.charAt(0) === " ") c = c.substring(1);
+    if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
+  }
+  return "";
+};
+const removeCookie = (cname) => {
+  if ((0, import_types.isUndefined)(import_globals.document) || (0, import_types.isUndefined)(import_globals.document.cookie)) return;
+  import_globals.document.cookie = cname + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
+};
+function getLocalStorage(key) {
+  if (!window.localStorage) {
+    return void 0;
+  }
+  const item = window.localStorage.getItem(key);
+  if (item === null) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(item);
+  } catch (e) {
+    return void 0;
+  }
+}
+function setLocalStorage(key, data) {
+  if (!window.localStorage || data === void 0 || data === null) {
+    return;
+  }
+  const value = typeof data === "object" ? JSON.stringify(data) : data;
+  window.localStorage.setItem(key, value);
+}

package/dist/cjs/date.js

@@ -16,14 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/date.js
 var date_exports = {};
 __export(date_exports, {
   formatDate: () => formatDate
 });
 module.exports = __toCommonJS(date_exports);
-var formatDate = (timestamp) => {
+const formatDate = (timestamp) => {
   if (!timestamp) return "";
   const d = new Date(timestamp);
   const ye = new Intl.DateTimeFormat("en", { year: "numeric" }).format(d);

package/dist/cjs/detectHeight.js

@@ -16,14 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/detectHeight.js
 var detectHeight_exports = {};
 __export(detectHeight_exports, {
   detectHeightOnInit: () => detectHeightOnInit
 });
 module.exports = __toCommonJS(detectHeight_exports);
-var detectHeightOnInit = (element, state) => {
+const detectHeightOnInit = (element, state) => {
   const heightTimeout = setTimeout(() => {
     const { props } = element;
     if (!state.clientHeight) {
@@ -36,14 +34,14 @@ var detectHeightOnInit = (element, state) => {
     }
     if (state.active) {
       if (props.height === "auto") return;
-      element.setProps(
+      element.update(
         {
           height: state.clientHeight
         },
         { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
       );
       const setAutoTimeout = setTimeout(() => {
-        element.setProps(
+        element.update(
           {
             height: "auto"
           },
@@ -52,7 +50,7 @@ var detectHeightOnInit = (element, state) => {
         clearTimeout(setAutoTimeout);
       }, 450);
     } else {
-      element.setProps(
+      element.update(
         {
           height: "0"
         },

package/dist/cjs/element.js

@@ -0,0 +1,136 @@
+"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 element_exports = {};
+__export(element_exports, {
+  addCaching: () => addCaching,
+  addContext: () => addContext,
+  addRef: () => addRef,
+  createBasedOnType: () => createBasedOnType,
+  createElement: () => createElement,
+  createParent: () => createParent,
+  createPath: () => createPath,
+  createRoot: () => createRoot,
+  returnValueAsText: () => returnValueAsText
+});
+module.exports = __toCommonJS(element_exports);
+var import_extends = require("./extends.js");
+var import_key = require("./key.js");
+var import_node = require("./node.js");
+var import_props = require("./props.js");
+var import_tags = require("./tags.js");
+var import_types = require("./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 = import_tags.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 ((0, import_types.is)(element)("string", "number")) {
+    return returnValueAsText(element, parent, key);
+  }
+  if ((0, import_types.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 ((0, import_node.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 = (0, import_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 = (0, import_key.createKey)(element, parent, passedKey);
+  addCaching(element, parent, key);
+  const props = (0, import_props.createProps)(element, parent, key);
+  const context = addContext(element, parent, key, opts, root);
+  const on = element.on || {};
+  return {
+    ...element,
+    key,
+    props,
+    parent,
+    context,
+    on
+  };
+};

package/dist/cjs/env.js

@@ -0,0 +1,43 @@
+"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 env_exports = {};
+__export(env_exports, {
+  ENV: () => ENV,
+  NODE_ENV: () => NODE_ENV,
+  getNev: () => getNev,
+  isDevelopment: () => isDevelopment,
+  isLocal: () => isLocal,
+  isNotProduction: () => isNotProduction,
+  isProduction: () => isProduction,
+  isStaging: () => isStaging,
+  isTest: () => isTest,
+  isTesting: () => isTesting
+});
+module.exports = __toCommonJS(env_exports);
+// @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);

package/dist/cjs/events.js

@@ -0,0 +1,39 @@
+"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 events_exports = {};
+__export(events_exports, {
+  addEventFromProps: () => addEventFromProps
+});
+module.exports = __toCommonJS(events_exports);
+var import_string = require("./string.js");
+var import_types = require("./types.js");
+function addEventFromProps(key, obj) {
+  const { props, on } = obj;
+  const eventName = (0, import_string.lowercaseFirstLetter)(key.split("on")[1]);
+  const origEvent = on[eventName];
+  const funcFromProps = props[key];
+  if ((0, import_types.isFunction)(origEvent)) {
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args);
+      if (originalEventRetunrs !== false) {
+        if ((0, import_types.isFunction)(funcFromProps)) return funcFromProps(...args);
+      }
+    };
+  } else on[eventName] = funcFromProps;
+}