@symbo.ls/connect 3.2.7

package/dist/content.js

@@ -0,0 +1,1171 @@
+// node_modules/@domql/utils/globals.js
+var window2 = globalThis;
+var document2 = window2.document;
+
+// node_modules/@domql/utils/node.js
+var isDOMNode = (obj) => {
+  return typeof window2 !== "undefined" && (obj instanceof window2.Node || obj instanceof window2.Window || obj === window2 || obj === document);
+};
+
+// node_modules/@domql/utils/types.js
+var isFunction = (arg) => typeof arg === "function";
+var isNull = (arg) => arg === null;
+var isArray = (arg) => Array.isArray(arg);
+var isObjectLike = (arg) => {
+  if (arg === null) return false;
+  return typeof arg === "object";
+};
+var isUndefined = (arg) => {
+  return arg === void 0;
+};
+
+// node_modules/@domql/utils/array.js
+var mergeArray = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+    {}
+  );
+};
+
+// node_modules/@domql/utils/object.js
+var deepMerge = (element, extend, excludeFrom = [], level = Infinity) => {
+  for (const e in extend) {
+    const hasOwnProperty = Object.prototype.hasOwnProperty.call(extend, e);
+    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith("__"))
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
+      if (level > 0) {
+        deepMerge(elementProp, extendProp, excludeFrom, level - 1);
+      } else {
+        for (const k in extendProp) {
+          if (excludeFrom.includes(k) || elementProp[k] !== void 0) continue;
+          elementProp[k] = extendProp[k];
+        }
+      }
+    } else if (elementProp === void 0) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+var deepClone = (obj, options = {}) => {
+  const {
+    exclude = [],
+    cleanUndefined = false,
+    cleanNull = false,
+    window: targetWindow,
+    visited = /* @__PURE__ */ new WeakMap(),
+    handleExtend = false
+  } = options;
+  const contentWindow = targetWindow || window2 || globalThis;
+  if (!isObjectLike(obj) || isDOMNode(obj)) {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const clone = contentWindow ? isArray(obj) ? new contentWindow.Array() : new contentWindow.Object() : isArray(obj) ? [] : {};
+  visited.set(obj, clone);
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__")
+      continue;
+    let value = obj[key];
+    if (cleanUndefined && isUndefined(value) || cleanNull && isNull(value))
+      continue;
+    if (isDOMNode(value)) {
+      clone[key] = value;
+      continue;
+    }
+    if (handleExtend && key === "extend" && isArray(value)) {
+      clone[key] = mergeArray(value, exclude);
+      continue;
+    }
+    if (isFunction(value) && options.window) {
+      clone[key] = contentWindow.eval("(" + value.toString() + ")");
+      continue;
+    }
+    if (value?.__ref && value?.node) {
+      value = value.parseDeep();
+    }
+    if (value?.__element) {
+      value = value.parse();
+    }
+    if (isObjectLike(value)) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      clone[key] = deepClone(value, {
+        ...options,
+        visited
+      });
+    } else {
+      clone[key] = value;
+    }
+  }
+  return clone;
+};
+
+// node_modules/@domql/utils/cookie.js
+var isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+
+// src/grabber/utils.js
+var allEqual = (arr) => arr.every((v) => v === arr[0]);
+var capitalize = (string) => string.charAt(0).toUpperCase() + string.slice(1);
+var toCamelCase = (str) => str.replace(
+  /[_\- ]+(?<first>[a-z])/giu,
+  (_, char, offSet) => offSet > 0 ? char.toUpperCase() : char
+);
+function extractCssVars(styles) {
+  const cssVariables = {};
+  for (const key in styles) {
+    if (Object.hasOwn(styles, key) && key.includes("--")) {
+      cssVariables[key] = styles[key];
+    }
+  }
+  return cssVariables;
+}
+function convertKeysToCamelCase(styles) {
+  const camelCased = {};
+  for (const key in styles) {
+    if (Object.hasOwn(styles, key) && !key.includes("--")) {
+      camelCased[toCamelCase(key)] = styles[key];
+    }
+  }
+  return camelCased;
+}
+function findVarPattern(input) {
+  const regex = /var\(--(?<varName>[a-zA-Z0-9-]+)(?:,\s*[a-zA-Z0-9%-]+)?\)/gu;
+  const matches = [];
+  let match = regex.exec(input);
+  while (match !== null) {
+    const varName = `--${match.groups.varName}`;
+    matches.push(varName);
+    match = regex.exec(input);
+  }
+  return [...new Set(matches)];
+}
+var extractRootVars = (css, globalStyles) => {
+  const variables = extractCssVars(css);
+  let rootVars = Object.values(css).reduce((acc, value) => {
+    const vars = {};
+    if (value.includes("var(")) {
+      const varNames = findVarPattern(value);
+      varNames.forEach((v) => {
+        let val = variables[v];
+        if (val || val === "") {
+          vars[v] = val || " ";
+        } else {
+          val = globalStyles.getPropertyValue(v);
+          if (val || val === "") {
+            vars[v] = val || " ";
+          }
+        }
+      });
+    }
+    return { ...acc, ...vars };
+  }, {});
+  if (Object.keys(rootVars).length) {
+    let checkingNested = true;
+    let nested = {};
+    while (checkingNested) {
+      const parsed = Object.values({
+        ...rootVars,
+        ...variables,
+        ...nested
+      }).reduce(
+        /*  eslint-disable-next-line no-loop-func -- checking the contents of rootVars and nested is safe */
+        (acc, value) => {
+          const vars = {};
+          if (value.includes("var(")) {
+            const varNames = findVarPattern(value);
+            varNames.forEach((v) => {
+              if (v in rootVars || v in nested) {
+                return;
+              }
+              let val = variables[v];
+              if (val || val === "") {
+                vars[v] = val || " ";
+              } else {
+                val = globalStyles.getPropertyValue(v);
+                if (val || val === "") {
+                  vars[v] = val || " ";
+                }
+              }
+            });
+          }
+          return { ...acc, ...vars };
+        },
+        {}
+      );
+      if (Object.keys(parsed).length) {
+        nested = { ...nested, ...parsed };
+      } else {
+        checkingNested = false;
+      }
+    }
+    rootVars = { ...rootVars, ...nested };
+  }
+  return rootVars;
+};
+function isEqual(objA, objB, visited = /* @__PURE__ */ new WeakSet()) {
+  if (objA === objB) {
+    return true;
+  }
+  if (objA == null || objB == null) {
+    return false;
+  }
+  if (typeof objA !== "object" || typeof objB !== "object") {
+    return false;
+  }
+  if (visited.has(objA) || visited.has(objB)) {
+    return false;
+  }
+  visited.add(objA);
+  visited.add(objB);
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!keysB.includes(key) || !isEqual(objA[key], objB[key], visited)) {
+      return false;
+    }
+  }
+  return true;
+}
+function cleanSharedProperties(children) {
+  const props = children.map((child) => child.props);
+  const shared = {};
+  const keys = Object.keys(props[0]);
+  for (const key of keys) {
+    const values = props.map((style) => style[key]);
+    if (values.every((value) => isEqual(value, values[0]))) {
+      const [val] = values;
+      shared[key] = val;
+    }
+  }
+  return shared;
+}
+function reformatChildren(children) {
+  const childrenObj = {};
+  const keyCounts = {};
+  children.forEach((child) => {
+    let key = child.extend ?? "Child";
+    if (Array.isArray(key)) {
+      key = child.extend.shift();
+      if (!child.extend.length) {
+        delete child.extend;
+      }
+    }
+    if (!(key in keyCounts)) {
+      keyCounts[key] = 0;
+    }
+    keyCounts[key]++;
+    const newKey = keyCounts[key] > 1 ? `${key}_${keyCounts[key]}` : key;
+    childrenObj[newKey] = { ...child };
+  });
+  return childrenObj;
+}
+
+// src/grabber/clean.js
+function consolidateValues(values) {
+  const uniqueValues = new Set(values);
+  if (uniqueValues.size === 1) {
+    return values[0];
+  }
+  if (uniqueValues.size === 2) {
+    const [vertical, horizontal] = values;
+    if (vertical === horizontal) {
+      return `${vertical}`;
+    }
+  } else if (uniqueValues.size === 4) {
+    const [topLeft, topRight, bottomRight, bottomLeft] = values;
+    if (topLeft === topRight && bottomLeft === bottomRight) {
+      return `${topLeft} ${bottomLeft}`;
+    }
+  }
+  return values.join(" ");
+}
+function consolidateTextDecoration(style) {
+  const updatedStyle = deepClone(style);
+  const decorationProps = [
+    "textDecorationThickness",
+    "textDecorationStyle",
+    "textDecorationColor"
+  ];
+  const thickness = style.textDecorationThickness && style.textDecorationThickness !== "initial" ? style.textDecorationThickness : "";
+  const styleProp = style.textDecorationStyle && style.textDecorationStyle !== "initial" ? style.textDecorationStyle : "";
+  const color = style.textDecorationColor && style.textDecorationColor !== "initial" ? style.textDecorationColor : "";
+  const consolidatedTextDecoration = [thickness, styleProp, color].filter(Boolean).join(" ").trim();
+  if (consolidatedTextDecoration) {
+    updatedStyle.textDecoration = consolidatedTextDecoration;
+  }
+  decorationProps.forEach((prop) => delete updatedStyle[prop]);
+  return updatedStyle;
+}
+function consolidateBorderRadius(style) {
+  const radiusProps = [
+    "borderBottomLeftRadius",
+    "borderBottomRightRadius",
+    "borderEndEndRadius",
+    "borderEndStartRadius",
+    "borderStartEndRadius",
+    "borderStartStartRadius",
+    "borderTopLeftRadius",
+    "borderTopRightRadius"
+  ];
+  const sides = ["TopLeft", "TopRight", "BottomRight", "BottomLeft"];
+  const radii = [];
+  sides.forEach((side) => {
+    const radius = style[`border${side}Radius`];
+    if (radius && radius !== "initial") {
+      radii.push(radius);
+    } else {
+      radii.push("0");
+    }
+  });
+  const consolidatedRadius = consolidateValues(radii).trim();
+  const updated = { ...style };
+  if (consolidatedRadius && consolidatedRadius !== "0") {
+    updated.borderRadius = consolidatedRadius;
+  }
+  radiusProps.forEach((prop) => delete updated[prop]);
+  return updated;
+}
+function consolidateAndUpdateBorderProperties(style) {
+  const updatedStyle = deepClone(style);
+  const result = {};
+  const sides = ["Top", "Right", "Bottom", "Left"];
+  const properties = ["Width", "Style", "Color"];
+  const borderProps = {};
+  sides.forEach((side) => {
+    properties.forEach((prop) => {
+      const key = `border${side}${prop}`;
+      if (updatedStyle[key] && updatedStyle[key] !== "initial") {
+        borderProps[key] = updatedStyle[key];
+      }
+    });
+  });
+  const allSidesEqual = properties.every(
+    (prop) => allEqual(sides.map((side) => borderProps[`border${side}${prop}`]))
+  );
+  if (allSidesEqual) {
+    const width = borderProps.borderTopWidth;
+    const borderStyle = borderProps.borderTopStyle;
+    const color = borderProps.borderTopColor;
+    if (width && borderStyle && color) {
+      result.border = `${width} ${borderStyle} ${color}`;
+    } else {
+      if (width) {
+        result.borderWidth = width;
+      }
+      if (borderStyle) {
+        result.borderStyle = borderStyle;
+      }
+      if (color) {
+        result.borderColor = color;
+      }
+    }
+  } else {
+    const logicalSides = ["BlockStart", "BlockEnd", "InlineStart", "InlineEnd"];
+    const logicalEqual = properties.every(
+      (prop) => allEqual(logicalSides.map((side) => borderProps[`border${side}${prop}`]))
+    );
+    if (logicalEqual) {
+      const blockWidth = borderProps.borderBlockStartWidth;
+      const blockStyle = borderProps.borderBlockStartStyle;
+      const blockColor = borderProps.borderBlockStartColor;
+      const inlineWidth = borderProps.borderInlineStartWidth;
+      const inlineStyle = borderProps.borderInlineStartStyle;
+      const inlineColor = borderProps.borderInlineStartColor;
+      if (blockWidth === inlineWidth && blockStyle === inlineStyle && blockColor === inlineColor) {
+        result.border = `${blockWidth} ${blockStyle} ${blockColor}`;
+      } else {
+        if (blockWidth) {
+          result.borderBlockWidth = blockWidth;
+        }
+        if (blockStyle) {
+          result.borderBlockStyle = blockStyle;
+        }
+        if (blockColor) {
+          result.borderBlockColor = blockColor;
+        }
+        if (inlineWidth && inlineWidth !== blockWidth) {
+          result.borderInlineWidth = inlineWidth;
+        }
+        if (inlineStyle && inlineStyle !== blockStyle) {
+          result.borderInlineStyle = inlineStyle;
+        }
+        if (inlineColor && inlineColor !== blockColor) {
+          result.borderInlineColor = inlineColor;
+        }
+      }
+    } else {
+      logicalSides.forEach((side) => {
+        const width = borderProps[`border${side}Width`];
+        const borderStyle = borderProps[`border${side}Style`];
+        const color = borderProps[`border${side}Color`];
+        if (width && borderStyle && color) {
+          result[`border${side}`] = `${width} ${borderStyle} ${color}`;
+        } else {
+          if (width) {
+            result[`border${side}Width`] = width;
+          }
+          if (borderStyle) {
+            result[`border${side}Style`] = borderStyle;
+          }
+          if (color) {
+            result[`border${side}Color`] = color;
+          }
+        }
+      });
+    }
+  }
+  ;
+  [
+    "borderImageSource",
+    "borderImageSlice",
+    "borderImageWidth",
+    "borderImageOutset",
+    "borderImageRepeat"
+  ].forEach((prop) => {
+    if (updatedStyle[prop] && updatedStyle[prop] !== "initial") {
+      result[prop] = updatedStyle[prop];
+    }
+    delete updatedStyle[prop];
+  });
+  sides.forEach((side) => {
+    properties.forEach((prop) => {
+      delete updatedStyle[`border${side}${prop}`];
+    });
+  });
+  [
+    "border",
+    "borderWidth",
+    "borderStyle",
+    "borderColor",
+    "borderBlock",
+    "borderInline"
+  ].forEach((prop) => {
+    delete updatedStyle[prop];
+  });
+  return { ...updatedStyle, ...result };
+}
+function consolidateSpacing(style, property = "padding") {
+  const updatedStyle = deepClone(style);
+  const propertyMap = {
+    top: style[`${property}Top`] || style[`${property}BlockStart`] || style[`${property}Block`],
+    right: style[`${property}Right`] || style[`${property}InlineEnd`] || style[`${property}Inline`],
+    bottom: style[`${property}Bottom`] || style[`${property}BlockEnd`] || style[`${property}Block`],
+    left: style[`${property}Left`] || style[`${property}InlineStart`] || style[`${property}Inline`]
+  };
+  const consolidatedValues = ["top", "right", "bottom", "left"].map(
+    (side) => propertyMap[side] || "0"
+  );
+  if (consolidatedValues.every((value) => value === "0")) {
+    return updatedStyle;
+  }
+  const [top, right, bottom, left] = consolidatedValues;
+  let result = consolidatedValues.join(" ");
+  if (right === left) {
+    if (top === bottom) {
+      if (top === right) {
+        result = top;
+      } else {
+        result = `${top} ${right}`;
+      }
+    } else {
+      result = `${top} ${right} ${bottom}`;
+    }
+  }
+  ;
+  [
+    `${property}Top`,
+    `${property}Right`,
+    `${property}Bottom`,
+    `${property}Left`,
+    `${property}BlockStart`,
+    `${property}BlockEnd`,
+    `${property}InlineStart`,
+    `${property}InlineEnd`,
+    `${property}Block`,
+    `${property}Inline`,
+    property
+  ].forEach((prop) => {
+    delete updatedStyle[prop];
+  });
+  updatedStyle[property] = result;
+  return updatedStyle;
+}
+function splitPropsFromStyles(style) {
+  const updatedStyle = deepClone(style);
+  const props = {};
+  const stylesWithProps = [
+    "alignContent",
+    "alignItems",
+    "alignSelf",
+    "animation",
+    "animationDelay",
+    "animationDirection",
+    "animationDuration",
+    "animationFillMode",
+    "animationIterationCount",
+    "animationName",
+    "animationPlayState",
+    "animationTimingFunction",
+    "appearance",
+    "aspectRatio",
+    "background",
+    "backgroundColor",
+    "backgroundPosition",
+    "backgroundRepeat",
+    "backgroundSize",
+    "backfaceVisibility",
+    "backdropFilter",
+    "blockSize",
+    "border",
+    "borderBottom",
+    "borderColor",
+    "borderLeft",
+    "borderRadius",
+    "borderRight",
+    "borderStyle",
+    "borderTop",
+    "borderWidth",
+    "bottom",
+    "boxShadow",
+    "boxSize",
+    "boxSizing",
+    "caretColor",
+    "columns",
+    "columnCount",
+    "columnFill",
+    "columnGap",
+    "columnRule",
+    "columnRule",
+    "columnSpan",
+    "columnWidth",
+    "color",
+    "content",
+    "cursor",
+    "depth",
+    "direction",
+    "direction",
+    "display",
+    "filter",
+    "flex",
+    "flexAlign",
+    "flexDirection",
+    "flexFlow",
+    "flexWrap",
+    "float",
+    "gap",
+    "gridArea",
+    "gridColumn",
+    "gridColumnStart",
+    "gridRow",
+    "gridRowStart",
+    "height",
+    "heightRange",
+    "horizontalInset",
+    "inlineSize",
+    "inset",
+    "justifyContent",
+    "justifyItems",
+    "left",
+    "maxBlockSize",
+    "maxHeight",
+    "maxInlineSize",
+    "maxSize",
+    "maxWidth",
+    "mixBlendMode",
+    "minBlockSize",
+    "minHeight",
+    "minInlineSize",
+    "minSize",
+    "minWidth",
+    "margin",
+    "marginBlock",
+    "marginBlockEnd",
+    "marginBlockStart",
+    "marginInline",
+    "marginInlineEnd",
+    "marginInlineStart",
+    "objectFit",
+    "opacity",
+    "order",
+    "overflow",
+    "overflowX",
+    "overflowY",
+    "outline",
+    "outlineOffset",
+    "overscrollBehavior",
+    "padding",
+    "paddingBlock",
+    "paddingBlockEnd",
+    "paddingBlockStart",
+    "paddingInline",
+    "paddingInlineEnd",
+    "paddingInlineStart",
+    "perspective",
+    "perspectiveOrigin",
+    "pointerEvents",
+    "position",
+    "right",
+    "resize",
+    "round",
+    "rowGap",
+    "scrollPadding",
+    "shape",
+    "shapeDirection",
+    "shapeDirectionColor",
+    "shadow",
+    "size",
+    "textShadow",
+    "textStroke",
+    "theme",
+    "top",
+    "transform",
+    "transformOrigin",
+    "transition",
+    "transitionDelay",
+    "transitionDuration",
+    "transitionProperty",
+    "transitionTimingFunction",
+    "userSelect",
+    "verticalAlign",
+    "verticalInset",
+    "visibility",
+    "width",
+    "widthRange",
+    "willChange",
+    "zIndex",
+    "zoom"
+  ];
+  stylesWithProps.forEach((key) => {
+    if (key in updatedStyle) {
+      props[key] = updatedStyle[key];
+      delete updatedStyle[key];
+    }
+  });
+  return { props, style: updatedStyle };
+}
+function consolidateStyles(style) {
+  let updatedStyle = deepClone(style);
+  if (style.outlineWidth || style.outlineStyle || style.outlineColor) {
+    updatedStyle.outline = `${style.outlineWidth || "initial"} ${style.outlineStyle || "initial"} ${style.outlineColor || "initial"}`;
+    delete updatedStyle.outlineWidth;
+    delete updatedStyle.outlineStyle;
+    delete updatedStyle.outlineColor;
+  }
+  const insetProps = [
+    "insetInlineStart",
+    "insetBlockEnd",
+    "insetInlineEnd",
+    "insetBlockStart"
+  ];
+  const insetValues = insetProps.map((prop) => style[prop] || "0");
+  if (insetValues.some((val) => val !== "0")) {
+    updatedStyle.inset = consolidateValues(insetValues);
+    insetProps.forEach((prop) => delete updatedStyle[prop]);
+  }
+  if (style.transition && style.transitionProperty && style.transitionDuration) {
+    updatedStyle.transition = `${style.transition} ${style.transitionProperty} ${style.transitionDuration}`;
+    delete updatedStyle.transitionProperty;
+    delete updatedStyle.transitionDuration;
+  }
+  const sizeProps = ["inlineSize", "blockSize"];
+  const sizeValues = sizeProps.map((prop) => style[prop] || "0");
+  if (sizeValues.some((val) => val !== "0")) {
+    updatedStyle.size = consolidateValues(sizeValues);
+    sizeProps.forEach((prop) => delete updatedStyle[prop]);
+  }
+  let gapValues = [];
+  if (style.gap) {
+    gapValues = [...gapValues, ...style.gap.split(" ")];
+    delete updatedStyle.gap;
+  }
+  const gapProps = ["rowGap", "columnGap"];
+  gapValues = [...gapValues, ...gapProps.map((prop) => style[prop] || "0")];
+  if (gapValues.some((val) => val !== "0")) {
+    updatedStyle.gap = consolidateValues(gapValues);
+    gapProps.forEach((prop) => delete updatedStyle[prop]);
+  }
+  if (style.webkitTextStroke) {
+    updatedStyle.textStroke = style.webkitTextStroke;
+    delete updatedStyle.webkitTextStroke;
+  }
+  updatedStyle = consolidateBorderRadius(updatedStyle);
+  updatedStyle = consolidateAndUpdateBorderProperties(updatedStyle);
+  updatedStyle = consolidateSpacing(updatedStyle, "padding");
+  updatedStyle = consolidateSpacing(updatedStyle, "margin");
+  updatedStyle = consolidateSpacing(updatedStyle, "borderWidth");
+  updatedStyle = consolidateTextDecoration(updatedStyle);
+  if (style.minWidth && style.maxWidth) {
+    updatedStyle.widthRange = `${style.minWidth} ${style.maxWidth}`;
+    delete updatedStyle.minWidth;
+    delete updatedStyle.maxWidth;
+  }
+  if (style.minHeight && style.maxHeight) {
+    style.heightRange = `${style.minHeight} ${style.maxHeight}`;
+    delete updatedStyle.minHeight;
+    delete updatedStyle.maxHeight;
+  }
+  return updatedStyle;
+}
+function consolidateFlexCSS(props) {
+  const updatedProps = deepClone(props);
+  if (props.alignItems || props.justifyContent) {
+    updatedProps.align = `${props.alignItems || ""} ${props.justifyContent || ""}`.trim();
+    delete updatedProps.alignItems;
+    delete updatedProps.justifyContent;
+  }
+  if (props.flexDirection || props.flexWrap) {
+    updatedProps.flow = `${props.flexDirection || "row"} ${props.flexWrap || ""}`.trim();
+    delete updatedProps.flexDirection;
+    delete updatedProps.flexWrap;
+  }
+  return updatedProps;
+}
+function consolidateGridCSS(props) {
+  const updatedProps = deepClone(props);
+  if (props.gridTemplateColumns) {
+    updatedProps.columns = props.gridTemplateColumns;
+    delete updatedProps.gridTemplateColumns;
+  }
+  if (props.gridTemplateRows) {
+    updatedProps.rows = props.gridTemplateRows;
+    delete updatedProps.gridTemplateRows;
+  }
+  return updatedProps;
+}
+
+// src/grabber/computed.js
+function getComputedStyles(node) {
+  const computedStyle = window.getComputedStyle(node);
+  const style = {};
+  for (let i = 0; i < computedStyle.length; i++) {
+    const property = computedStyle[i];
+    const value = computedStyle.getPropertyValue(property);
+    style[property] = value;
+  }
+  return style;
+}
+function getStyleDefaultsFromEmptyNode(tag) {
+  const node = document.createElement(tag);
+  document.body.appendChild(node);
+  const computed = getComputedStyles(node);
+  document.body.removeChild(node);
+  return computed;
+}
+function getAppliedComputedStyles(node, defaults) {
+  const css = getComputedStyles(node);
+  const styles = {};
+  Object.keys(css).forEach((prop) => {
+    const value = css[prop];
+    const ignoreAllVals = [
+      "width",
+      "height",
+      "inline-size",
+      "block-size",
+      "transform-origin",
+      "perspective-origin"
+    ];
+    const ignoreAutoVals = [
+      "margin",
+      "margin-top",
+      "margin-bottom",
+      "margin-left",
+      "margin-right",
+      "padding",
+      "padding-top",
+      "padding-bottom",
+      "padding-left",
+      "padding-right",
+      "top",
+      "bottom",
+      "left",
+      "right",
+      "min-width",
+      "min-height",
+      "min-block-size",
+      "min-inline-size"
+    ];
+    const skipDefault = [["flex-direction", (s) => s.display === "flex"]];
+    const defaultIsValid = skipDefault.some(([p, con]) => prop === p && con(css)) || value !== defaults[prop];
+    if (!ignoreAllVals.includes(prop) && value && defaultIsValid && !(ignoreAutoVals.includes(prop) && value === "auto")) {
+      styles[prop] = value;
+    }
+  });
+  return styles;
+}
+
+// src/settings/settings_utils.js
+var storageKey = "settings";
+var getSettings = async () => (await chrome.storage.local.get(storageKey)).settings;
+
+// src/grabber/stylesheets.js
+var getRelevantRules = (node, rules) => {
+  let relevantRules = [];
+  for (const rule of rules) {
+    const { selectorText, conditionText, media, cssRules } = rule;
+    if (selectorText && node.matches(selectorText)) {
+      relevantRules.push(rule);
+    } else if ((conditionText || media && media.length > 0) && cssRules) {
+      relevantRules = [
+        ...relevantRules,
+        ...getRelevantRules(node, rule.cssRules)
+      ];
+    }
+  }
+  return relevantRules;
+};
+var extractStylesFromRule = (rule, defaults = {}) => {
+  const { style } = rule;
+  const results = {};
+  for (let k = 0; k < style.length; k++) {
+    const prop = style[k];
+    const value = style.getPropertyValue(prop);
+    const defaultValue = defaults[prop];
+    if (value && value !== defaultValue) {
+      results[prop] = value;
+    }
+  }
+  return results;
+};
+var processMediaQueries = (rule, parentRule) => {
+  const { conditionText } = parentRule;
+  let key = `@media ${conditionText}`;
+  if (["(prefers-color-scheme: dark)", "(prefers-color-scheme: light)"].includes(
+    conditionText
+  )) {
+    key = conditionText.includes("dark") ? "@dark" : "@light";
+  }
+  return { [key]: { ...extractStylesFromRule(rule) } };
+};
+var getAppliedStylesheets = (node) => {
+  let styles = {};
+  let conditionalStyles = {};
+  for (const styleSheet of document.styleSheets) {
+    let baseRules = null;
+    try {
+      baseRules = styleSheet.cssRules;
+    } catch (error) {
+      console.log("Could not access stylesheet rules:", { styleSheet, error });
+    }
+    if (baseRules !== null) {
+      const rules = getRelevantRules(node, baseRules);
+      for (const rule of rules) {
+        const { parentRule } = rule;
+        if (parentRule && parentRule.conditionText) {
+          conditionalStyles = {
+            ...conditionalStyles,
+            ...processMediaQueries(rule, parentRule)
+          };
+        } else if (rule.selectorText.includes(":hover")) {
+          const hoverKey = ":hover";
+          conditionalStyles[hoverKey] = {
+            ...conditionalStyles[hoverKey],
+            ...extractStylesFromRule(rule)
+          };
+        } else {
+          styles = { ...styles, ...extractStylesFromRule(rule) };
+        }
+      }
+    }
+  }
+  return [styles, conditionalStyles];
+};
+var getInlineStyles = (node, defaults) => {
+  const styles = {};
+  for (let i = 0; i < node.style.length; i++) {
+    const prop = node.style[i];
+    const val = node.style.getPropertyValue(prop);
+    if (val && val !== defaults[prop]) {
+      styles[prop] = val;
+    }
+  }
+  return styles;
+};
+function getAllAppliedSheetStyles(node, defaults) {
+  const inlineStyles = getInlineStyles(node, defaults);
+  const [stylesheetStyles, conditionalStyles] = getAppliedStylesheets(node);
+  return [{ ...stylesheetStyles, ...inlineStyles }, conditionalStyles];
+}
+
+// src/grabber/parse.js
+function getNodeText(node) {
+  if (node.nodeType === window.Node.TEXT_NODE) {
+    return window.Node.TEXT_NODE;
+  }
+  let val = "";
+  for (const child of node.childNodes) {
+    if (child.nodeType === window.Node.TEXT_NODE && child.textContent.trim() !== "") {
+      val += child.textContent.trim();
+    }
+  }
+  if (val.trim() !== "") {
+    return val;
+  }
+}
+function parseNodeAttributes(node) {
+  const attributes = {};
+  if (node && node.attributes) {
+    for (const { name, value } of node.attributes) {
+      if (name !== "class" && name !== "style") {
+        attributes[name] = value;
+      }
+    }
+  }
+  return Object.keys(attributes).length ? attributes : null;
+}
+function extendsFromTag(props) {
+  const extend = [];
+  const tag = (props.tag ?? "div").toLowerCase();
+  if (tag === "a") {
+    extend.push("Link");
+  }
+  const validTags = [
+    "input",
+    "button",
+    "img",
+    "span",
+    "strong",
+    "section",
+    "picture",
+    "form",
+    "dialog",
+    "p",
+    "hr",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "header",
+    "footer",
+    "progress",
+    "select",
+    "textarea",
+    "aside",
+    "pre",
+    "code",
+    "svg",
+    "label",
+    "hgroup"
+  ];
+  if (validTags.includes(tag)) {
+    extend.push(capitalize(tag));
+  }
+  return extend;
+}
+async function parseElement(node, rootStyles) {
+  const tag = node.tagName.toLowerCase();
+  const defaults = getStyleDefaultsFromEmptyNode(tag);
+  const settings = await getSettings();
+  const [sheets, conditionalSheets] = settings.useStylesheets ?? true ? getAllAppliedSheetStyles(node, defaults) : {};
+  const computed = settings.useComputed ? getAppliedComputedStyles(node, defaults) : {};
+  const rawStyles = {
+    ...sheets,
+    ...computed
+  };
+  let rootVars = extractRootVars(rawStyles, rootStyles);
+  const camelCased = convertKeysToCamelCase(rawStyles);
+  const camelCasedConditionals = {};
+  Object.entries(conditionalSheets).forEach(([query, cSheet]) => {
+    rootVars = { ...extractRootVars(cSheet, rootStyles), ...rootVars };
+    const { props: props2, style: style2 } = splitPropsFromStyles(
+      convertKeysToCamelCase(cSheet)
+    );
+    camelCasedConditionals[query] = {};
+    if (Object.keys(props2).length) {
+      camelCasedConditionals[query] = props2;
+    }
+    if (Object.keys(style2).length) {
+      camelCasedConditionals[query].style = style2;
+    }
+  });
+  let props = { ...rootVars };
+  if (tag !== "div") {
+    props.tag = tag;
+  }
+  const { props: styleProps, style } = splitPropsFromStyles(
+    consolidateStyles(camelCased)
+  );
+  props = { ...props, ...styleProps };
+  const text = getNodeText(node);
+  let children = [];
+  const childPromises = [];
+  if (node.children.length > 0) {
+    const ignore = ["STYLE", "SCRIPT"];
+    for (const childNode of node.children) {
+      if (!ignore.includes(childNode.tagName)) {
+        if (childNode.tagName === "svg") {
+          const html = childNode.innerHTML;
+          const attr2 = parseNodeAttributes(childNode);
+          children.push({
+            extend: ["Svg"],
+            attr: attr2,
+            props: { html }
+          });
+        } else {
+          childPromises.push(parseElement(childNode, rootStyles));
+        }
+      }
+    }
+  }
+  const results = await Promise.all(childPromises);
+  children = [...children, ...results];
+  let childProps = null;
+  if (children.length > 1) {
+    childProps = cleanSharedProperties(children);
+    Object.keys(childProps).forEach((key) => {
+      children.forEach((child) => delete child.props[key]);
+    });
+  }
+  const attr = parseNodeAttributes(node);
+  const copyAttrFromThese = ["a", "img", "input", "button", "iframe"];
+  if (attr && copyAttrFromThese.includes(tag)) {
+    Object.keys(attr).forEach((prop) => {
+      props[prop] = attr[prop];
+      delete attr[prop];
+    });
+  }
+  if (tag === "img" && props.src && props.src.startsWith("/")) {
+    props.src = window.location.origin + props.src;
+  }
+  if (tag === "a" && props.href && props.href.startsWith("/")) {
+    props.href = window.location.origin + props.href;
+  }
+  const extend = extendsFromTag(props);
+  if (extend.length === 1) {
+    delete props.tag;
+  }
+  if (props.display === "flex") {
+    props = consolidateFlexCSS(props);
+    delete props.display;
+    extend.push("Flex");
+  }
+  if (props.display === "grid") {
+    props = consolidateGridCSS(props);
+    delete props.display;
+    extend.push("Grid");
+  }
+  let element = {
+    props: { ...props }
+  };
+  if (Object.keys(style).length) {
+    element.props.style = style;
+  }
+  if (Object.keys(camelCasedConditionals).length) {
+    element.props = { ...element.props, ...camelCasedConditionals };
+  }
+  if (text) {
+    element.props.text = text;
+  }
+  if (attr && Object.keys(attr).length) {
+    element.props.attr = attr;
+  }
+  if (extend.length) {
+    element.extend = extend;
+  }
+  if (children.length) {
+    if (childProps && Object.keys(childProps).length) {
+      element.props.childProps = childProps;
+    }
+    element = { ...element, ...reformatChildren(children) };
+  } else if (childProps) {
+    console.warn("childProps without children");
+  }
+  return element;
+}
+
+// src/content.js
+function injectPageAgent() {
+  const script = document.createElement("script");
+  script.src = chrome.runtime.getURL("page-agent.js");
+  script.onload = () => script.remove();
+  (document.head || document.documentElement).appendChild(script);
+}
+injectPageAgent();
+async function addToLibrary(node) {
+  const rootStyles = window.getComputedStyle(document.documentElement);
+  const obj = await parseElement(node, rootStyles);
+  const store = { domqlStr: JSON.stringify(obj) };
+  console.log("%c[Symbols] saving domql", "color: green", store);
+  chrome.storage.local.set(store);
+  chrome.runtime.sendMessage({ type: "open_platform" });
+  return obj;
+}
+var focusNodeClass = "symbols-grabber-hovered";
+var isListenerActive = false;
+var focusedNode = null;
+document.body.addEventListener(
+  "mouseover",
+  (event) => {
+    const { target } = event;
+    if (target && isListenerActive) {
+      if (focusedNode && focusedNode !== target) {
+        focusedNode.classList.remove(focusNodeClass);
+      }
+      focusedNode = target;
+      focusedNode.classList.add(focusNodeClass);
+    }
+  },
+  true
+);
+chrome.runtime.onMessage.addListener((msg, sender, respond) => {
+  if (sender.id === chrome.runtime.id) {
+    const { type, state } = msg;
+    if (type === "toggle" && typeof state === "number") {
+      console.log(
+        `%c[Symbols] grabber ${state ? "enabled" : "disabled"}`,
+        `color: ${state ? "green" : "red"}`
+      );
+      isListenerActive = Boolean(state);
+      document.body.classList.toggle("symbols-grabber-active", isListenerActive);
+      if (!state) {
+        document.querySelectorAll(`.${focusNodeClass}`).forEach((el) => {
+          el.classList.remove(focusNodeClass);
+        });
+        focusedNode = null;
+      }
+      document.body.addEventListener(
+        "click",
+        (event) => {
+          const { target } = event;
+          if (target && isListenerActive) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            if (target.classList.contains(focusNodeClass)) {
+              target.classList.remove(focusNodeClass);
+            }
+            addToLibrary(target).then(
+              (domql) => {
+                target.classList.add(focusNodeClass);
+                respond({ success: true, domql });
+              },
+              (error) => {
+                console.error("[Symbols] error adding to library", error);
+                respond({ success: false, error: error.message || error });
+              }
+            );
+            isListenerActive = false;
+          }
+        },
+        { capture: true, once: true }
+      );
+    }
+  }
+  return true;
+});
+console.log("[Symbols] Content script loaded (inspector + grabber)");
+/*! Bundled license information:
+
+@domql/utils/env.js:
+  (* @preserve-env *)
+*/
+//# sourceMappingURL=content.js.map