domql 1.5.113 → 1.5.115

package/dist/cjs/element/applyParam.js

@@ -0,0 +1,41 @@
+"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 applyParam_exports = {};
+__export(applyParam_exports, {
+  applyParam: () => applyParam
+});
+module.exports = __toCommonJS(applyParam_exports);
+var import_utils = require("@domql/utils");
+var import_mixins = require("./mixins");
+const applyParam = (param, element, options) => {
+  const { node, context } = element;
+  const prop = element[param];
+  const DOMQLProperty = import_mixins.registry[param];
+  const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+  const hasDefine = element.define && element.define[param];
+  const hasContextDefine = context && context.define && context.define[param];
+  if (isGlobalTransformer && !hasContextDefine) {
+    if ((0, import_utils.isFunction)(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options);
+      return;
+    }
+  }
+  return { hasDefine, hasContextDefine };
+};

package/{packages/utils/dist/function.js → dist/cjs/element/assign.js}

@@ -16,31 +16,20 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var function_exports = {};
-__export(function_exports, {
-  debounce: () => debounce,
-  memoize: () => memoize
+var assign_exports = {};
+__export(assign_exports, {
+  appendNode: () => appendNode,
+  assignNode: () => assignNode
 });
-module.exports = __toCommonJS(function_exports);
-const debounce = (element, func, timeout = 300) => {
-  let timer;
-  return (...args) => {
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      func.apply(element, args);
-    }, timeout);
-  };
+module.exports = __toCommonJS(assign_exports);
+const appendNode = (node, parentNode) => {
+  parentNode.appendChild(node);
+  return node;
 };
-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 assignNode = (element, parent, key) => {
+  parent[key || element.key] = element;
+  if (element.tag !== "shadow") {
+    appendNode(element.node, parent.node);
+  }
+  return element;
 };

package/dist/cjs/element/cache.js

@@ -0,0 +1,74 @@
+"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, {
+  default: () => cache_default,
+  detectTag: () => detectTag
+});
+module.exports = __toCommonJS(cache_exports);
+var import_globals = require("@domql/globals");
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+var import_event = require("../event");
+var import_utils2 = require("../utils");
+const cachedElements = {};
+const createNode = (element) => {
+  const { tag } = element;
+  if (tag) {
+    if (tag === "string")
+      return import_globals.document.createTextNode(element.text);
+    else if (tag === "fragment") {
+      return import_globals.document.createDocumentFragment();
+    } else if (tag === "svg" || tag === "path") {
+      return import_globals.document.createElementNS("http://www.w3.org/2000/svg", tag);
+    } else
+      return import_globals.document.createElement(tag);
+  } else {
+    return import_globals.document.createElement("div");
+  }
+};
+const detectTag = (element) => {
+  let { tag, key } = element;
+  tag = (0, import_utils.exec)(tag, element);
+  if (tag === true)
+    tag = key;
+  if ((0, import_utils.isString)(tag)) {
+    const tagExists = (0, import_utils2.isTagRegistered)(tag) > -1;
+    if (tagExists)
+      return tag;
+  } else {
+    const isKeyATag = (0, import_utils2.isTagRegistered)(key) > -1;
+    if (isKeyATag)
+      return key;
+  }
+  return "div";
+};
+var cache_default = (element) => {
+  const tag = element.tag = detectTag(element);
+  if (!import_event.can.render(element)) {
+    return (0, import_report.report)("HTMLInvalidTag");
+  }
+  let cachedTag = cachedElements[tag];
+  if (!cachedTag)
+    cachedTag = cachedElements[tag] = createNode(element);
+  const clonedNode = cachedTag.cloneNode(true);
+  if (tag === "string")
+    clonedNode.nodeValue = element.text;
+  return clonedNode;
+};

package/dist/cjs/element/create.js

@@ -0,0 +1,305 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_exports = {};
+__export(create_exports, {
+  default: () => create_default
+});
+module.exports = __toCommonJS(create_exports);
+var import_utils = require("@domql/utils");
+var import_registry = require("@domql/registry");
+var import_root = __toESM(require("./root"));
+var import_node = __toESM(require("./node"));
+var import_assign = require("./assign");
+var import_extend = require("./extend");
+var import_set = __toESM(require("./set"));
+var import_state = __toESM(require("./state"));
+var import_props = __toESM(require("./props"));
+var import_update = __toESM(require("./update"));
+var import_event = require("../event");
+var import_classList = require("./mixins/classList");
+var import_methods = require("./methods");
+var import_cache = __toESM(require("./cache"));
+var import_mixins = require("./mixins");
+var import_iterate = require("./iterate");
+var import_options = __toESM(require("./options"));
+const ENV = "development";
+const create = (element, parent, key, options = import_options.default.create || {}) => {
+  if (options && !import_options.default.create)
+    import_options.default.create = options;
+  if (element === void 0) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
+    }
+    element = {};
+  }
+  if ((0, import_utils.isString)(key) && key.slice(0, 2 === "__")) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(key, "seems like to be in __ref");
+    }
+  }
+  if (element === null)
+    return;
+  if (element === true)
+    element = { text: true };
+  if (element.__hash) {
+    element = { extend: element };
+  }
+  if (!parent)
+    parent = import_root.default;
+  if ((0, import_utils.isNode)(parent))
+    parent = import_root.default[`${key}_parent`] = { key: ":root", node: parent };
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  const assignedKey = (element.key || key || (0, import_utils.createID)()).toString();
+  if (checkIfKeyIsComponent(assignedKey)) {
+    element = applyKeyComponentAsExtend(element, parent, assignedKey);
+  }
+  if (checkIfMedia(assignedKey)) {
+    element = applyMediaProps(element, parent, assignedKey);
+  }
+  if (element.__ref)
+    element.__ref.origin = element;
+  else
+    element.__ref = { origin: element };
+  const __ref = element.__ref;
+  applyContext(element, parent, options);
+  const { context } = element;
+  if (context && context.components)
+    applyComponentFromContext(element, parent, options);
+  (0, import_extend.applyExtend)(element, parent, options);
+  element.key = assignedKey;
+  if (options.onlyResolveExtends)
+    return resolveExtends(element, parent, options);
+  if (Object.keys(options).length) {
+    import_mixins.registry.defaultOptions = options;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
+  }
+  addCaching(element, parent);
+  addMethods(element, parent);
+  element.state = (0, import_state.default)(element, parent);
+  checkIf(element, parent);
+  if (element.node && __ref.__if) {
+    return (0, import_assign.assignNode)(element, parent, assignedKey);
+  }
+  if (__ref.__if)
+    (0, import_props.default)(element, parent);
+  if (element.on && (0, import_utils.isFunction)(element.on.init)) {
+    import_event.on.init(element.on.init, element, element.state);
+  }
+  if (element.on && (0, import_utils.isFunction)(element.on.beforeClassAssign)) {
+    import_event.on.beforeClassAssign(element.on.beforeClassAssign, element, element.state);
+  }
+  (0, import_classList.assignClass)(element);
+  (0, import_node.default)(element, options);
+  if (!__ref.__if)
+    return element;
+  (0, import_assign.assignNode)(element, parent, key);
+  if (element.on && (0, import_utils.isFunction)(element.on.render)) {
+    import_event.on.render(element.on.render, element, element.state);
+  }
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
+  return element;
+};
+const checkIfPrimitive = (element) => {
+  return (0, import_utils.is)(element)("string", "number");
+};
+const applyValueAsText = (element, parent, key) => {
+  const extendTag = element.extend && element.extend.tag;
+  const childExtendTag = parent.childExtend && parent.childExtend.tag;
+  const isKeyValidHTMLTag = import_registry.TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || isKeyValidHTMLTag || "string"
+  };
+};
+const addMethods = (element, parent) => {
+  element.set = import_set.default;
+  element.update = import_update.default;
+  element.remove = import_methods.remove;
+  element.removeContent = import_set.removeContentElement;
+  element.setProps = import_methods.setProps;
+  element.lookup = import_methods.lookup;
+  element.spotByPath = import_methods.spotByPath;
+  element.parse = import_methods.parse;
+  element.parseDeep = import_methods.parseDeep;
+  element.keys = import_methods.keys;
+  element.nextElement = import_methods.nextElement;
+  element.previousElement = import_methods.previousElement;
+  if (ENV === "test" || ENV === "development") {
+    element.log = import_methods.log;
+  }
+};
+const applyContext = (element, parent, options) => {
+  if (options.context && !import_root.default.context && !element.context)
+    import_root.default.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || import_root.default.context;
+};
+const checkIf = (element, parent) => {
+  const { __ref } = element;
+  if ((0, import_utils.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    if (!ifPassed) {
+      const ifFragment = (0, import_cache.default)({ tag: "fragment" });
+      __ref.__ifFragment = (0, import_assign.appendNode)(ifFragment, parent.node);
+      delete __ref.__if;
+    } else
+      __ref.__if = true;
+  } else
+    __ref.__if = true;
+};
+const addCaching = (element, parent) => {
+  const { __ref } = element;
+  let { __ref: __parentRef } = parent;
+  if (!element.transform)
+    element.transform = {};
+  if (!__ref.__cached)
+    __ref.__cached = {};
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  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 = [];
+  const hasRoot = parent && parent.key === ":root";
+  if (!__ref.__root)
+    __ref.__root = hasRoot ? element : parent.__ref.__root;
+  if (ENV === "test" || ENV === "development") {
+    if (!__parentRef)
+      __parentRef = parent.__ref = {};
+    if (!__parentRef.__path)
+      __parentRef.__path = [];
+    __ref.__path = __parentRef.__path.concat(element.key);
+  }
+};
+const resolveExtends = (element, parent, options) => {
+  const { __ref } = element;
+  element.tag = (0, import_cache.detectTag)(element);
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  element.props = {};
+  element.state = {};
+  element.props = (0, import_props.default)(element, parent);
+  element.state = (0, import_state.default)(element, parent, { skip: true });
+  (0, import_iterate.throughInitialExec)(element);
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || prop === void 0)
+      continue;
+    const hasDefined = element.define && element.define[param];
+    const ourParam = import_mixins.registry[param];
+    const hasOptionsDefine = options.define && options.define[param];
+    if (ourParam && !hasOptionsDefine)
+      continue;
+    else if (element[param] && !hasDefined && !hasOptionsDefine) {
+      create((0, import_utils.exec)(prop, element), element, param, options);
+    }
+  }
+  delete element.parent;
+  delete element.update;
+  delete element.__element;
+  delete element.__props;
+  delete element.props.props;
+  delete element.state.__element;
+  delete element.state.__element;
+  delete element.__hasRootState;
+  delete element.__ref;
+  return element;
+};
+const checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = (0, import_utils.isString)(key);
+  if (!isFirstKeyString)
+    return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[A-Z]*$/.test(firstCharKey);
+};
+const extendizeByKey = (element, parent, key) => {
+  const { extend, props, state, childExtend, childProps } = element;
+  const hasComponentAttrs = extend || childExtend || props || state || element.on;
+  const componentKey = key.split("_")[0];
+  if (!hasComponentAttrs || childProps) {
+    return {
+      extend: componentKey || key,
+      props: { ...element }
+    };
+  } else if (!extend || extend === true) {
+    return {
+      ...element,
+      extend: componentKey || key
+    };
+  }
+};
+const applyKeyComponentAsExtend = (element, parent, key) => {
+  return extendizeByKey(element, parent, key) || element;
+};
+const applyComponentFromContext = (element, parent, options) => {
+  const { context } = element;
+  const { components } = context;
+  const { extend } = element;
+  const execExtend = (0, import_utils.exec)(extend, element);
+  if ((0, import_utils.isString)(execExtend)) {
+    if (components[execExtend])
+      element.extend = components[execExtend];
+    else {
+      if ((ENV === "test" || ENV === "development") && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+const checkIfMedia = (key) => key.slice(0, 1) === "@";
+const applyMediaProps = (element, parent, key) => {
+  const { props } = element;
+  if (props) {
+    props.display = "none";
+    if (props[key])
+      props[key].display = props.display;
+    else
+      props[key] = { display: props.display || "block" };
+    return element;
+  } else {
+    return {
+      ...element,
+      props: {
+        display: "none",
+        [key]: { display: "block" }
+      }
+    };
+  }
+};
+var create_default = create;

package/dist/cjs/element/define.js

@@ -0,0 +1,34 @@
+"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 define_exports = {};
+__export(define_exports, {
+  default: () => define_default
+});
+module.exports = __toCommonJS(define_exports);
+var import_report = require("@domql/report");
+var import_mixins = require("./mixins");
+var define_default = (params, options = {}) => {
+  const { overwrite } = options;
+  for (const param in params) {
+    if (import_mixins.registry[param] && !overwrite) {
+      (0, import_report.report)("OverwriteToBuiltin", param);
+    } else
+      import_mixins.registry[param] = params[param];
+  }
+};

package/dist/cjs/element/extend.js

@@ -0,0 +1,74 @@
+"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 extend_exports = {};
+__export(extend_exports, {
+  applyExtend: () => applyExtend
+});
+module.exports = __toCommonJS(extend_exports);
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+const ENV = "development";
+const applyExtend = (element, parent, options = {}) => {
+  if ((0, import_utils.isFunction)(element))
+    element = (0, import_utils.exec)(element, parent);
+  let { extend, props, context, __ref } = element;
+  const COMPONENTS = context && context.components || options.components;
+  if ((0, import_utils.isString)(extend))
+    extend = COMPONENTS[extend];
+  const extendStack = (0, import_utils2.getExtendStack)(extend);
+  if (ENV !== "test" || ENV !== "development")
+    delete element.extend;
+  let childExtendStack = [];
+  if (parent) {
+    element.parent = parent;
+    if (!options.ignoreChildExtend) {
+      if (props && props.ignoreChildExtend)
+        return;
+      childExtendStack = (0, import_utils2.getExtendStack)(parent.childExtend);
+      if (parent.childExtendRecursive) {
+        const childExtendRecursiveStack = (0, import_utils2.getExtendStack)(parent.childExtendRecursive);
+        childExtendStack = childExtendStack.concat(childExtendRecursiveStack);
+        element.childExtendRecursive = parent.childExtendRecursive;
+      }
+    }
+  }
+  const extendLength = extendStack.length;
+  const childExtendLength = childExtendStack.length;
+  let stack = [];
+  if (extendLength && childExtendLength) {
+    stack = (0, import_utils2.jointStacks)(extendStack, childExtendStack);
+  } else if (extendLength) {
+    stack = extendStack;
+  } else if (childExtendLength) {
+    stack = childExtendStack;
+  } else if (!options.extend)
+    return element;
+  if (options.extend) {
+    const defaultOptionsExtend = (0, import_utils2.getExtendStack)(options.extend);
+    stack = [].concat(stack, defaultOptionsExtend);
+  }
+  __ref.__extend = stack;
+  let mergedExtend = (0, import_utils2.cloneAndMergeArrayExtend)(stack);
+  const component = (0, import_utils.exec)(element.component || mergedExtend.component, element);
+  if (component && COMPONENTS && COMPONENTS[component]) {
+    const componentExtend = (0, import_utils2.cloneAndMergeArrayExtend)((0, import_utils2.getExtendStack)(COMPONENTS[component]));
+    mergedExtend = (0, import_utils2.deepMergeExtend)(componentExtend, mergedExtend);
+  }
+  return (0, import_utils2.deepMergeExtend)(element, mergedExtend);
+};

package/dist/cjs/element/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var element_exports = {};
+__export(element_exports, {
+  assign: () => assign,
+  cache: () => import_cache.default,
+  create: () => import_create.default,
+  createNode: () => import_node.default,
+  define: () => import_define.default,
+  get: () => import_methods.get,
+  keys: () => import_methods.keys,
+  log: () => import_methods.log,
+  lookup: () => import_methods.lookup,
+  parse: () => import_parse.default,
+  remove: () => import_methods.remove,
+  root: () => import_root.default,
+  set: () => import_set.default,
+  setProps: () => import_methods.setProps,
+  tree: () => import_tree.default,
+  update: () => import_update.default
+});
+module.exports = __toCommonJS(element_exports);
+var import_root = __toESM(require("./root"));
+var import_tree = __toESM(require("./tree"));
+var import_cache = __toESM(require("./cache"));
+var import_create = __toESM(require("./create"));
+var import_node = __toESM(require("./node"));
+var assign = __toESM(require("./assign"));
+var import_define = __toESM(require("./define"));
+var import_update = __toESM(require("./update"));
+var import_parse = __toESM(require("./parse"));
+var import_set = __toESM(require("./set"));
+var import_methods = require("./methods");