@qelos/aidev 0.11.0 → 1.0.1

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/constraint-validation/ValidityState-impl.js

@@ -0,0 +1,66 @@
+"use strict";
+
+exports.implementation = class ValidityStateImpl {
+  constructor(globalObject, args, privateData) {
+    const { element, state = {} } = privateData;
+
+    this._element = element;
+    this._state = state;
+  }
+
+  get badInput() {
+    return this._failsConstraint("badInput");
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#suffering-from-a-custom-error
+  get customError() {
+    return this._element._customValidityErrorMessage !== "";
+  }
+
+  get patternMismatch() {
+    return this._failsConstraint("patternMismatch");
+  }
+
+  get rangeOverflow() {
+    return this._failsConstraint("rangeOverflow");
+  }
+
+  get rangeUnderflow() {
+    return this._failsConstraint("rangeUnderflow");
+  }
+
+  get stepMismatch() {
+    return this._failsConstraint("stepMismatch");
+  }
+
+  get tooLong() {
+    return this._failsConstraint("tooLong");
+  }
+
+  get tooShort() {
+    return this._failsConstraint("tooShort");
+  }
+
+  get typeMismatch() {
+    return this._failsConstraint("typeMismatch");
+  }
+
+  get valueMissing() {
+    return this._failsConstraint("valueMissing");
+  }
+
+  _failsConstraint(method) {
+    const validationMethod = this._state[method];
+    if (validationMethod) {
+      return validationMethod();
+    }
+
+    return false;
+  }
+
+  get valid() {
+    return !(this.badInput || this.valueMissing || this.customError ||
+            this.patternMismatch || this.rangeOverflow || this.rangeUnderflow ||
+            this.stepMismatch || this.tooLong || this.tooShort || this.typeMismatch);
+  }
+};

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/crypto/Crypto-impl.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const nodeCrypto = require("crypto");
+const DOMException = require("../../../generated/idl/DOMException");
+
+// https://w3c.github.io/webcrypto/#crypto-interface
+class CryptoImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+  }
+
+  // https://w3c.github.io/webcrypto/#Crypto-method-getRandomValues
+  getRandomValues(array) {
+    const typeName = getTypedArrayTypeName(array);
+    if (!(typeName === "Int8Array" ||
+        typeName === "Uint8Array" ||
+        typeName === "Uint8ClampedArray" ||
+        typeName === "Int16Array" ||
+        typeName === "Uint16Array" ||
+        typeName === "Int32Array" ||
+        typeName === "Uint32Array" ||
+        typeName === "BigInt64Array" ||
+        typeName === "BigUint64Array")) {
+      throw DOMException.create(this._globalObject, [
+        `getRandomValues() only accepts integer typed arrays`,
+        "TypeMismatchError"
+      ]);
+    }
+
+    if (array.byteLength > 65536) {
+      throw DOMException.create(this._globalObject, [
+        `getRandomValues() cannot generate more than 65536 bytes of random values; ` +
+        `${array.byteLength} bytes were requested`,
+        "QuotaExceededError"
+      ]);
+    }
+    nodeCrypto.randomFillSync(array);
+    return array;
+  }
+
+  // https://w3c.github.io/webcrypto/#Crypto-method-randomUUID
+  randomUUID() {
+    return nodeCrypto.randomUUID();
+  }
+}
+
+exports.implementation = CryptoImpl;
+
+// See #3395. Subclasses of TypedArrays should properly work, but we can't rely
+// on instanceof because Uint8Array may be different across different windows -
+// which can happen in JSDOM when running { runScripts: "dangerously" }. As a
+// solution, we imitate the behavior of instanceof by walking the proottype
+// chain.
+function getTypedArrayTypeName(array) {
+  const target = array.constructor;
+  const chain = [target.name];
+  let proto = Object.getPrototypeOf(target);
+  while (proto) {
+    chain.push(proto.name);
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  while (chain.length > 0 && chain[chain.length - 1] !== "TypedArray") {
+    chain.pop();
+  }
+  chain.reverse();
+  return chain[1];
+}

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSConditionRule-impl.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const CSSGroupingRuleImpl = require("./CSSGroupingRule-impl.js").implementation;
+
+class CSSConditionRuleImpl extends CSSGroupingRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._conditionText = privateData.conditionText;
+  }
+
+  // Getter required: CSSMediaRule overrides this, so an own data property would shadow it.
+  get conditionText() {
+    return this._conditionText;
+  }
+}
+
+exports.implementation = CSSConditionRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSContainerRule-impl.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const CSSConditionRuleImpl = require("./CSSConditionRule-impl.js").implementation;
+const { serializeGroupingRuleBody } = require("./CSSGroupingRule-impl.js");
+const { serializeCustomIdent } = require("./helpers/css-values.js");
+
+// https://drafts.csswg.org/css-conditional-5/#typedef-container-name
+const containerNameExclusions = new Set(["none", "and", "or", "not"]);
+
+class CSSContainerRuleImpl extends CSSConditionRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.containerName = privateData.containerName;
+    this.containerQuery = privateData.containerQuery;
+  }
+
+  get conditionText() {
+    if (this.containerName) {
+      return serializeCustomIdent(this.containerName, containerNameExclusions) + " " + this.containerQuery;
+    }
+    return this.containerQuery;
+  }
+
+  get type() {
+    return 0; // No standard type constant for container rules
+  }
+
+  get cssText() {
+    return `@container ${this.conditionText} ${serializeGroupingRuleBody(this.cssRules._list)}`;
+  }
+}
+
+exports.implementation = CSSContainerRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSCounterStyleRule-impl.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const { serializeCustomIdent } = require("./helpers/css-values.js");
+
+// https://drafts.csswg.org/css-counter-styles-3/#typedef-counter-style-name
+const counterStyleExclusions = new Set(
+  ["none", "decimal", "disc", "square", "circle", "disclosure-open", "disclosure-closed"]
+);
+
+// TODO: implement these as proper getters and setters that follow the spec at
+// https://drafts.csswg.org/css-counter-styles-3/#csscounterstylerule, including serialization,
+// parsing, special handling for certain values, etc.
+const descriptorNames = [
+  "system", "symbols", "additiveSymbols", "negative",
+  "prefix", "suffix", "range", "pad", "speakAs", "fallback"
+];
+
+class CSSCounterStyleRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.name = privateData.name;
+    for (const desc of descriptorNames) {
+      this[desc] = "";
+    }
+  }
+
+  get type() {
+    return 11; // COUNTER_STYLE_RULE
+  }
+
+  get cssText() {
+    const parts = [];
+    for (const desc of descriptorNames) {
+      if (this[desc]) {
+        // Convert camelCase to kebab-case for CSS property names
+        const cssName = desc.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`);
+        parts.push(`${cssName}: ${this[desc]};`);
+      }
+    }
+    return `@counter-style ${serializeCustomIdent(this.name, counterStyleExclusions)} { ${parts.join(" ")} }`;
+  }
+}
+
+exports.implementation = CSSCounterStyleRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSFontFaceRule-impl.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const CSSStyleDeclaration = require("../../../generated/idl/CSSStyleDeclaration.js");
+
+class CSSFontFaceRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.style = CSSStyleDeclaration.createImpl(globalObject, [], {
+      parentRule: this
+    });
+  }
+
+  get type() {
+    return 5; // FONT_FACE_RULE
+  }
+
+  get cssText() {
+    return `@font-face { ${this.style.cssText} }`;
+  }
+}
+
+exports.implementation = CSSFontFaceRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSGroupingRule-impl.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const CSSRuleList = require("../../../generated/idl/CSSRuleList.js");
+const CSSStyleRule = require("../../../generated/idl/CSSStyleRule.js");
+
+class CSSGroupingRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.cssRules = CSSRuleList.createImpl(globalObject);
+  }
+
+  insertRule(rule, index) {
+    const result = this.cssRules._insert(rule, index, this._isInNestingContext(), this, this.parentStyleSheet);
+    this.parentStyleSheet?.ownerNode?._ownerDocument._clearStyleCache();
+    return result;
+  }
+
+  deleteRule(index) {
+    this.cssRules._remove(index);
+    this.parentStyleSheet?.ownerNode?._ownerDocument._clearStyleCache();
+  }
+
+  _isInNestingContext() {
+    let ancestor = this;
+    while (ancestor) {
+      if (CSSStyleRule.isImpl(ancestor)) {
+        return true;
+      }
+      ancestor = ancestor.parentRule;
+    }
+    return false;
+  }
+}
+
+/**
+ * Serialize the body of a grouping rule per CSSOM spec.
+ * Produces multi-line output with indented child rules.
+ */
+function serializeGroupingRuleBody(rules) {
+  let body = "{\n";
+  for (const rule of rules) {
+    const ruleText = rule.cssText;
+    // Skip empty CSSNestedDeclarations per CSSOM serialization spec
+    if (ruleText) {
+      body += `  ${ruleText}\n`;
+    }
+  }
+  body += "}";
+  return body;
+}
+
+exports.implementation = CSSGroupingRuleImpl;
+exports.serializeGroupingRuleBody = serializeGroupingRuleBody;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSImportRule-impl.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const CSSStyleSheet = require("../../../generated/idl/CSSStyleSheet.js");
+const csstree = require("./helpers/patched-csstree.js");
+
+class CSSImportRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.href = privateData.href;
+    this.layerName = privateData.layerName;
+    this.supportsText = privateData.supportsText;
+
+    // Starts empty; populated later by stylesheets.js when the @import URL is fetched.
+    this.styleSheet = CSSStyleSheet.createImpl(globalObject, [], {
+      ownerRule: this,
+      parentStyleSheet: this.parentStyleSheet,
+      mediaText: privateData.mediaText,
+      constructed: false
+    });
+  }
+
+  // https://drafts.csswg.org/cssom/#dom-cssimportrule-media
+  get media() {
+    return this.styleSheet.media;
+  }
+
+  get type() {
+    return 3; // IMPORT_RULE
+  }
+
+  get cssText() {
+    // https://drafts.csswg.org/cssom/#serialize-a-url
+    // https://github.com/csstree/csstree/issues/360
+    let result = `@import url(${csstree.string.encode(this.href)})`;
+    if (this.layerName !== null) {
+      result += this.layerName ? ` layer(${this.layerName})` : " layer";
+    }
+    if (this.supportsText !== null) {
+      result += ` supports(${this.supportsText})`;
+    }
+    const { mediaText } = this.media;
+    if (mediaText) {
+      result += ` ${mediaText}`;
+    }
+    return result + ";";
+  }
+}
+
+exports.implementation = CSSImportRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSKeyframeRule-impl.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const DOMException = require("../../../generated/idl/DOMException.js");
+const CSSStyleProperties = require("../../../generated/idl/CSSStyleProperties.js");
+const csstree = require("./helpers/patched-csstree.js");
+
+function validateKeyframeSelector(selector) {
+  const ast = csstree.parse(selector, { context: "value" });
+  return !csstree.lexer.matchType("keyframe-selector", ast).error;
+}
+
+// Normalize a single keyframe selector: "from" → "0%", "To" → "100%", ".5%" → "0.5%", etc.
+function normalizeSelector(selector) {
+  const lower = selector.toLowerCase();
+  if (lower === "from") {
+    return "0%";
+  }
+  if (lower === "to") {
+    return "100%";
+  }
+  // Normalize the number: ".5%" → "0.5%", "100.0%" → "100%", "1e1%" → "10%"
+  return String(parseFloat(selector)) + "%";
+}
+
+function normalizeKeyText(text) {
+  return text.split(",").map(s => normalizeSelector(s.trim())).join(", ");
+}
+
+class CSSKeyframeRuleImpl extends CSSRuleImpl {
+  #keyText;
+
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.#keyText = normalizeKeyText(privateData.keyText);
+
+    this.style = CSSStyleProperties.createImpl(globalObject, [], {
+      parentRule: this
+    });
+  }
+
+  get type() {
+    return 8; // KEYFRAME_RULE
+  }
+
+  get keyText() {
+    return this.#keyText;
+  }
+
+  set keyText(value) {
+    const selectors = value.split(",").map(s => s.trim());
+    const normalized = [];
+    for (const sel of selectors) {
+      if (!validateKeyframeSelector(sel)) {
+        throw DOMException.create(this._globalObject, [
+          "Invalid keyframe selector.",
+          "SyntaxError"
+        ]);
+      }
+      normalized.push(normalizeSelector(sel));
+    }
+    this.#keyText = normalized.join(", ");
+  }
+
+  get cssText() {
+    return `${this.#keyText} { ${this.style.cssText} }`;
+  }
+}
+
+exports.implementation = CSSKeyframeRuleImpl;
+exports.normalizeKeyText = normalizeKeyText;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSKeyframesRule-impl.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const CSSRuleList = require("../../../generated/idl/CSSRuleList.js");
+const { normalizeKeyText } = require("./CSSKeyframeRule-impl.js");
+const cssParser = require("./helpers/css-parser.js");
+const idlUtils = require("../../../generated/idl/utils.js");
+const { serializeCustomIdent } = require("./helpers/css-values.js");
+
+// https://drafts.csswg.org/css-animations/#typedef-keyframes-name
+const keyframesExclusions = new Set(["none"]);
+
+class CSSKeyframesRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.name = privateData.name;
+    this.cssRules = CSSRuleList.createImpl(globalObject);
+  }
+
+  get type() {
+    return 7; // KEYFRAMES_RULE
+  }
+
+  get length() {
+    return this.cssRules._list.length;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return this.cssRules._list.keys();
+  }
+
+  [idlUtils.supportsPropertyIndex](index) {
+    return index >= 0 && index < this.cssRules._list.length;
+  }
+
+  [idlUtils.indexedGet](index) {
+    return this.cssRules._list[index];
+  }
+
+  appendRule(rule) {
+    const newRule = cssParser.parseKeyframeRule(rule, this._globalObject);
+    if (newRule === null) {
+      return;
+    }
+    newRule.parentRule = this;
+    newRule.parentStyleSheet = this.parentStyleSheet;
+    this.cssRules._list.push(newRule);
+  }
+
+  deleteRule(select) {
+    const normalized = normalizeKeyText(select);
+    const index = this.cssRules._list.findIndex(
+      r => r.keyText === normalized
+    );
+    if (index !== -1) {
+      const removed = this.cssRules._list[index];
+      removed.parentRule = null;
+      removed.parentStyleSheet = null;
+      this.cssRules._list.splice(index, 1);
+    }
+  }
+
+  findRule(select) {
+    const normalized = normalizeKeyText(select);
+    // Per spec, return the last matching rule
+    for (let i = this.cssRules._list.length - 1; i >= 0; i--) {
+      if (this.cssRules._list[i].keyText === normalized) {
+        return this.cssRules._list[i];
+      }
+    }
+    return null;
+  }
+
+  get cssText() {
+    const rules = this.cssRules._list.map(r => r.cssText).join(" ");
+    const name = serializeCustomIdent(this.name, keyframesExclusions);
+    return `@keyframes ${name} { ${rules} }`;
+  }
+}
+
+exports.implementation = CSSKeyframesRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSLayerBlockRule-impl.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const CSSGroupingRuleImpl = require("./CSSGroupingRule-impl.js").implementation;
+const { serializeGroupingRuleBody } = require("./CSSGroupingRule-impl.js");
+
+class CSSLayerBlockRuleImpl extends CSSGroupingRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.name = privateData.name;
+  }
+
+  get cssText() {
+    const name = this.name ? ` ${this.name}` : "";
+    return `@layer${name} ${serializeGroupingRuleBody(this.cssRules._list)}`;
+  }
+}
+
+exports.implementation = CSSLayerBlockRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSLayerStatementRule-impl.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+
+class CSSLayerStatementRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.nameList = Object.freeze(privateData.nameList);
+  }
+
+  get cssText() {
+    return `@layer ${this.nameList.join(", ")};`;
+  }
+}
+
+exports.implementation = CSSLayerStatementRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSMediaRule-impl.js

@@ -0,0 +1,34 @@
+"use strict";
+
+const CSSConditionRuleImpl = require("./CSSConditionRule-impl.js").implementation;
+const { serializeGroupingRuleBody } = require("./CSSGroupingRule-impl.js");
+const MediaList = require("../../../generated/idl/MediaList.js");
+const { evaluateMediaList } = require("./MediaList-impl.js");
+
+class CSSMediaRuleImpl extends CSSConditionRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this.media = MediaList.createImpl(globalObject, [], {
+      mediaText: this._conditionText
+    });
+  }
+
+  get type() {
+    return 4; // MEDIA_RULE
+  }
+
+  get matches() {
+    return evaluateMediaList(this.media._list);
+  }
+
+  get conditionText() {
+    return this.media.mediaText;
+  }
+
+  get cssText() {
+    return `@media ${this.media.mediaText} ${serializeGroupingRuleBody(this.cssRules._list)}`;
+  }
+}
+
+exports.implementation = CSSMediaRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSNamespaceRule-impl.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const csstree = require("./helpers/patched-csstree.js");
+
+class CSSNamespaceRuleImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.namespaceURI = privateData.namespaceURI;
+    this.prefix = privateData.prefix;
+  }
+
+  get type() {
+    return 10; // NAMESPACE_RULE
+  }
+
+  get cssText() {
+    // https://drafts.csswg.org/cssom/#serialize-a-url
+    // https://github.com/csstree/csstree/issues/360
+    const url = `url(${csstree.string.encode(this.namespaceURI)})`;
+    if (this.prefix) {
+      return `@namespace ${this.prefix} ${url};`;
+    }
+    return `@namespace ${url};`;
+  }
+}
+
+exports.implementation = CSSNamespaceRuleImpl;

package/ui/.output/server/node_modules/jsdom/lib/jsdom/living/css/CSSNestedDeclarations-impl.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const CSSRuleImpl = require("./CSSRule-impl.js").implementation;
+const CSSStyleProperties = require("../../../generated/idl/CSSStyleProperties.js");
+
+class CSSNestedDeclarationsImpl extends CSSRuleImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this.style = CSSStyleProperties.createImpl(globalObject, [], {
+      parentRule: this
+    });
+  }
+
+  get cssText() {
+    return this.style.cssText;
+  }
+}
+
+exports.implementation = CSSNestedDeclarationsImpl;