domql 1.6.4 → 1.6.6

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/dist/cjs/element/create.js

@@ -0,0 +1,266 @@
+"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_tree = require("@domql/tree");
+var import_key = require("@domql/key");
+var import_registry = require("@domql/registry");
+var import_event = require("@domql/event");
+var import_render = require("@domql/render");
+var import_methods = require("@domql/methods");
+var import_classlist = require("@domql/classlist");
+var import_node = require("@domql/node");
+var import_node2 = __toESM(require("./node"));
+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_methods2 = require("./methods");
+var import_mixins = require("./mixins");
+var import_iterate = require("./iterate");
+var import_options = __toESM(require("./options"));
+var import_component = require("../utils/component");
+var import_remove = require("./remove");
+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_tree.ROOT;
+  if ((0, import_utils.isNode)(parent)) {
+    parent = import_tree.ROOT[`${key}_parent`] = { key: ":root", node: parent };
+  }
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  const assignedKey = (element.key || key || (0, import_key.createKey)()).toString();
+  if ((0, import_component.checkIfKeyIsComponent)(assignedKey)) {
+    element = (0, import_component.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)
+    (0, import_component.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_render.assignNode)(element, parent, assignedKey);
+  }
+  if (__ref.__if)
+    (0, import_props.default)(element, parent);
+  const initReturns = (0, import_event.triggerEventOn)("init", element);
+  if (initReturns === false)
+    return element;
+  (0, import_event.triggerEventOn)("beforeClassAssign", element);
+  (0, import_classlist.assignClass)(element);
+  (0, import_node2.default)(element, options);
+  if (!__ref.__if)
+    return element;
+  (0, import_render.assignNode)(element, parent, key);
+  (0, import_event.triggerEventOn)("renderRouter", element);
+  (0, import_event.triggerEventOn)("render", element);
+  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_remove.removeContentElement;
+  element.setProps = import_methods.setProps;
+  element.lookup = import_methods.lookup;
+  element.spotByPath = import_methods.spotByPath;
+  element.parse = import_methods2.parse;
+  element.parseDeep = import_methods2.parseDeep;
+  element.keys = import_methods2.keys;
+  element.nextElement = import_methods2.nextElement;
+  element.previousElement = import_methods2.previousElement;
+  if (ENV === "test" || ENV === "development") {
+    element.log = import_methods2.log;
+  }
+};
+const applyContext = (element, parent, options) => {
+  if (options.context && !import_tree.ROOT.context && !element.context)
+    import_tree.ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || import_tree.ROOT.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_node.cacheNode)({ tag: "fragment" });
+      __ref.__ifFragment = (0, import_render.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 : __parentRef.__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_node.detectTag)(element);
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  if (!element.props)
+    element.props = {};
+  if (!element.state)
+    element.state = {};
+  element = (0, import_props.default)(element, parent);
+  (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.update;
+  delete element.props.__element;
+  delete element.state.__element;
+  delete element.state.__element;
+  delete element.__hasRootState;
+  delete element.__ref;
+  return element;
+};
+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,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 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;
+  const findAndReplaceStrings = (0, import_utils2.replaceStringsWithComponents)(stack, COMPONENTS);
+  let mergedExtend = (0, import_utils2.cloneAndMergeArrayExtend)(findAndReplaceStrings);
+  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,49 @@
+"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, {
+  TREE: () => import_tree.TREE,
+  create: () => import_create.default,
+  createNode: () => import_node.default,
+  define: () => import_define.default,
+  get: () => import_methods2.get,
+  keys: () => import_methods.keys,
+  log: () => import_methods.log,
+  lookup: () => import_methods2.lookup,
+  parse: () => import_parse.default,
+  remove: () => import_methods2.remove,
+  set: () => import_set.default,
+  update: () => import_update.default
+});
+module.exports = __toCommonJS(element_exports);
+var import_tree = require("@domql/tree");
+var import_create = __toESM(require("./create"));
+var import_node = __toESM(require("./node"));
+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");
+var import_methods2 = require("@domql/methods");

package/dist/cjs/element/iterate.js

@@ -0,0 +1,99 @@
+"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 iterate_exports = {};
+__export(iterate_exports, {
+  throughInitialDefine: () => throughInitialDefine,
+  throughInitialExec: () => throughInitialExec,
+  throughUpdatedDefine: () => throughUpdatedDefine,
+  throughUpdatedExec: () => throughUpdatedExec
+});
+module.exports = __toCommonJS(iterate_exports);
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+var import_methods = require("@domql/methods");
+const throughInitialExec = (element) => {
+  const { __ref } = element;
+  const { __exec } = __ref;
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param)) {
+      __exec[param] = prop;
+      element[param] = prop(element, element.state);
+    }
+  }
+};
+const throughUpdatedExec = (element, options) => {
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  for (const param in __exec) {
+    const prop = element[param];
+    const newExec = __exec[param](element, element.state);
+    if (prop && prop.node && ((0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec))) {
+      (0, import_utils2.overwrite)(prop, { text: newExec }, options);
+    } else if (newExec !== prop) {
+      __cached[param] = changes[param] = prop;
+      element[param] = newExec;
+    }
+  }
+  return changes;
+};
+const throughInitialDefine = (element) => {
+  const { define, context, __ref } = element;
+  const { __exec, __cached } = __ref;
+  let obj = {};
+  if ((0, import_utils.isObject)(define))
+    obj = { ...define };
+  if (context && (0, import_utils.isObject)(context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    let prop = element[param];
+    if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param)) {
+      __exec[param] = prop;
+      const execParam2 = prop = (0, import_utils.exec)(prop, element);
+      if (execParam2)
+        element[param] = execParam2;
+    }
+    __cached[param] = prop;
+    const execParam = obj[param](prop, element, element.state);
+    if (execParam)
+      element[param] = execParam;
+  }
+  return element;
+};
+const throughUpdatedDefine = (element) => {
+  const { context, define, __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  let obj = {};
+  if ((0, import_utils.isObject)(define))
+    obj = { ...define };
+  if ((0, import_utils.isObject)(context && context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    const execParam = __exec[param];
+    if (execParam)
+      __cached[param] = execParam(element, element.state);
+    const cached = (0, import_utils.exec)(__cached[param], element);
+    const newExecParam = obj[param](cached, element, element.state);
+    if (newExecParam)
+      element[param] = newExecParam;
+  }
+  return changes;
+};

package/dist/cjs/element/methods.js

@@ -0,0 +1,116 @@
+"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 methods_exports = {};
+__export(methods_exports, {
+  defineSetter: () => defineSetter,
+  keys: () => keys,
+  log: () => log,
+  nextElement: () => nextElement,
+  parse: () => parse,
+  parseDeep: () => parseDeep,
+  previousElement: () => previousElement,
+  set: () => set,
+  update: () => update
+});
+module.exports = __toCommonJS(methods_exports);
+var import_utils = require("@domql/utils");
+var import_mixins = require("./mixins");
+const set = function() {
+};
+const update = function() {
+};
+const defineSetter = (element, key, get, set2) => Object.defineProperty(element, key, { get, set: set2 });
+const keys = function() {
+  const element = this;
+  const keys2 = [];
+  for (const param in element) {
+    if (import_mixins.registry[param] && !import_mixins.parseFilters.elementKeys.includes(param)) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+};
+const parse = function(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => {
+    if (excl.includes(v))
+      return;
+    let val = element[v];
+    if (v === "state") {
+      if (element.__ref && element.__ref.__hasRootState)
+        return;
+      if ((0, import_utils.isFunction)(val == null ? void 0 : val.parse))
+        val = val.parse();
+    } else if (v === "props") {
+      const { __element, update: update2, ...props } = element[v];
+      obj[v] = props;
+    } else if ((0, import_utils.isDefined)(val))
+      obj[v] = val;
+  });
+  return obj;
+};
+const parseDeep = function(excl = []) {
+  const element = this;
+  const obj = parse.call(element, excl);
+  for (const v in obj) {
+    if (excl.includes(v))
+      return;
+    if ((0, import_utils.isObjectLike)(obj[v])) {
+      obj[v] = parseDeep.call(obj[v], excl);
+    }
+  }
+  return obj;
+};
+const log = function(...args) {
+  const element = this;
+  const { __ref } = element;
+  console.group(element.key);
+  if (args.length) {
+    args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  } else {
+    console.log(__ref.path);
+    const keys2 = element.keys();
+    keys2.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  }
+  console.groupEnd(element.key);
+  return element;
+};
+const nextElement = function() {
+  const element = this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  console.log(nextChild);
+  return parent[nextChild];
+};
+const previousElement = function(el) {
+  const element = el || this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  if (!__children)
+    return;
+  const currentIndex = __children.indexOf(key);
+  return parent[__children[currentIndex - 1]];
+};