@stacksjs/ts-css 0.1.0

package/dist/select/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * css-select adapter / option types. Drop-in compatible with css-select v5.
+ *
+ * The library is generic over the consumer's tree (`Node`/`ElementNode`),
+ * communicated via the `Adapter` interface — exactly the shape SVGO etc.
+ * already implement, so callers don't need to change a thing.
+ */
+export declare interface Adapter<Node, ElementNode extends Node> {
+  isTag: (node: Node) => node is ElementNode
+  existsOne: (test: (e: ElementNode) => boolean, elems: Node[]) => boolean
+  getAttributeValue: (elem: ElementNode, name: string) => string | undefined
+  getChildren: (node: Node) => Node[]
+  getName: (elem: ElementNode) => string
+  getParent: (elem: ElementNode | Node) => ElementNode | null
+  getSiblings: (elem: Node) => Node[]
+  getText: (node: Node) => string
+  hasAttrib: (elem: ElementNode, name: string) => boolean
+  removeSubsets: (nodes: Node[]) => Node[]
+  findAll?: (test: (e: ElementNode) => boolean, elems: Node[]) => ElementNode[]
+  findOne?: (test: (e: ElementNode) => boolean, elems: Node[]) => ElementNode | null
+  equals?: (a: Node, b: Node) => boolean
+  isActive?: (elem: ElementNode) => boolean
+  isVisited?: (elem: ElementNode) => boolean
+  isHovered?: (elem: ElementNode) => boolean
+}
+export declare interface Options<Node, ElementNode extends Node> {
+  xmlMode?: boolean
+  lowerCaseAttributeNames?: boolean
+  lowerCaseTags?: boolean
+  cacheResults?: boolean
+  adapter: Adapter<Node, ElementNode>
+  context?: Node | Node[]
+  pseudos?: Record<string, string | ((elem: ElementNode, value?: string) => boolean)>
+  rootFunc?: (elem: ElementNode) => boolean
+  relativeSelector?: boolean
+  quirksMode?: boolean
+}
+// eslint-disable-next-line pickier/no-unused-vars
+export type CompiledQuery<ElementNode> = (node: ElementNode) => boolean;
+// eslint-disable-next-line pickier/no-unused-vars
+export type Predicate<Value> = (v: Value) => boolean;

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public configuration shape for ts-css. Loaded by `bunfig` from
+ * `css.config.ts` (or `.json` / `.toml`) when present.
+ */
+export declare interface CSSConfig {
+  floatPrecision: number
+  verbose: boolean
+}
+export type CSSOptions = Partial<CSSConfig>;

package/dist/what/index.d.ts

@@ -0,0 +1,20 @@
+export type {
+  AttributeAction,
+  AttributeSelectorNode,
+  IgnoreCase,
+  ParseOptions,
+  PseudoElementNode,
+  PseudoSelectorNode,
+  Selector,
+  SelectorType,
+  TagSelectorNode,
+  TraversalNode,
+  UniversalSelectorNode,
+} from './types';
+/**
+ * Public surface — drop-in compatible with css-what v6.
+ */
+export { parse } from './parse';
+export { stringify } from './stringify';
+export { isTraversal } from './traversal';
+export { IgnoreCaseMode } from './types';

package/dist/what/index.js

@@ -0,0 +1,514 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/what/index.ts
+var exports_what = {};
+__export(exports_what, {
+  stringify: () => stringify,
+  parse: () => parse,
+  isTraversal: () => isTraversal,
+  IgnoreCaseMode: () => IgnoreCaseMode
+});
+
+// src/what/parse.ts
+var RE_NAME_STICKY = /(?:\\(?:[\dA-Fa-f]{1,6} ?|[^])|[\w\-\u00B0-\uFFFF])+/y;
+var RE_ESCAPE = /\\([\dA-Fa-f]{1,6} ?|[^])/g;
+function unescape(name) {
+  return name.replace(RE_ESCAPE, (_m, escape) => {
+    if (escape.length > 1 && /^[\dA-Fa-f]/.test(escape)) {
+      const code = Number.parseInt(escape, 16);
+      if (code >= 55296 && code <= 57343)
+        return "\uFFFD";
+      return String.fromCodePoint(code);
+    }
+    return escape;
+  });
+}
+function unescapeIfNeeded(name) {
+  return name.indexOf("\\") < 0 ? name : unescape(name);
+}
+var ATTRIBUTES_QUIRKS = new Set([
+  "accept",
+  "accept-charset",
+  "align",
+  "alink",
+  "axis",
+  "bgcolor",
+  "charset",
+  "checked",
+  "clear",
+  "codetype",
+  "color",
+  "compact",
+  "declare",
+  "defer",
+  "dir",
+  "direction",
+  "disabled",
+  "enctype",
+  "face",
+  "frame",
+  "hreflang",
+  "http-equiv",
+  "lang",
+  "language",
+  "link",
+  "media",
+  "method",
+  "multiple",
+  "nohref",
+  "noresize",
+  "noshade",
+  "nowrap",
+  "readonly",
+  "rel",
+  "rev",
+  "rules",
+  "scope",
+  "scrolling",
+  "selected",
+  "shape",
+  "target",
+  "text",
+  "type",
+  "valign",
+  "valuetype",
+  "vlink"
+]);
+function actionFromChar(ch) {
+  switch (ch) {
+    case 126:
+      return "element";
+    case 94:
+      return "start";
+    case 36:
+      return "end";
+    case 42:
+      return "any";
+    case 33:
+      return "not";
+    case 124:
+      return "hyphen";
+    default:
+      return null;
+  }
+}
+function isWsCode(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
+}
+function parse(selector, options = {}) {
+  const subselects = [];
+  const endIndex = parseSelectorImpl(subselects, selector, options, 0);
+  if (endIndex < selector.length)
+    throw new Error(`Unmatched selector: ${selector.slice(endIndex)}`);
+  return subselects;
+}
+function readName(selector, from) {
+  RE_NAME_STICKY.lastIndex = from;
+  const m = RE_NAME_STICKY.exec(selector);
+  if (!m)
+    throw new Error(`Expected name, found ${selector.slice(from)}`);
+  return { value: unescapeIfNeeded(m[0]), end: from + m[0].length };
+}
+function stripWS(selector, from) {
+  while (from < selector.length && isWsCode(selector.charCodeAt(from)))
+    from++;
+  return from;
+}
+function parseSelectorImpl(subselects, selector, options, startIndex) {
+  let tokens = [];
+  let i = stripWS(selector, startIndex);
+  const len = selector.length;
+  const xmlMode = options.xmlMode === true;
+  const lowerCaseAttrs = options.lowerCaseAttributeNames !== false && !xmlMode;
+  const lowerCaseTagsFlag = options.lowerCaseTags !== false;
+  while (i < len) {
+    const code = selector.charCodeAt(i);
+    if (isWsCode(code)) {
+      let trimmed = i + 1;
+      while (trimmed < len && isWsCode(selector.charCodeAt(trimmed)))
+        trimmed++;
+      if (tokens.length === 0)
+        return trimmed;
+      i = trimmed;
+      addTraversal(tokens, "descendant");
+      continue;
+    }
+    if (code === 62 || code === 60 || code === 126 || code === 43 || code === 124) {
+      let j = i + 1;
+      while (j < len && isWsCode(selector.charCodeAt(j)))
+        j++;
+      i = j;
+      switch (code) {
+        case 62:
+          addTraversal(tokens, "child");
+          break;
+        case 60:
+          addTraversal(tokens, "parent");
+          break;
+        case 126:
+          addTraversal(tokens, "sibling");
+          break;
+        case 43:
+          addTraversal(tokens, "adjacent");
+          break;
+        case 124:
+          if (i < len && selector.charCodeAt(i) === 124) {
+            i++;
+            i = stripWS(selector, i);
+            addTraversal(tokens, "column-combinator");
+          } else {
+            tokens.push({ type: "tag", name: "", namespace: "" });
+          }
+          break;
+      }
+      continue;
+    }
+    if (code === 44) {
+      if (tokens.length === 0)
+        throw new Error("Empty sub-selector");
+      subselects.push(tokens);
+      tokens = [];
+      i = stripWS(selector, i + 1);
+      continue;
+    }
+    if (code === 47 && selector.charCodeAt(i + 1) === 42) {
+      const end = selector.indexOf("*/", i + 2);
+      if (end < 0)
+        throw new Error("Unmatched comment");
+      i = stripWS(selector, end + 2);
+      continue;
+    }
+    if (code === 42) {
+      i++;
+      tokens.push({ type: "universal", namespace: null });
+      continue;
+    }
+    if (code === 35) {
+      const r = readName(selector, i + 1);
+      i = r.end;
+      tokens.push({
+        type: "attribute",
+        name: "id",
+        action: "equals",
+        value: r.value,
+        namespace: null,
+        ignoreCase: false
+      });
+      continue;
+    }
+    if (code === 46) {
+      const r = readName(selector, i + 1);
+      i = r.end;
+      tokens.push({
+        type: "attribute",
+        name: "class",
+        action: "element",
+        value: r.value,
+        namespace: null,
+        ignoreCase: false
+      });
+      continue;
+    }
+    if (code === 91) {
+      i = parseAttribute(selector, i, tokens, options, xmlMode, lowerCaseAttrs);
+      continue;
+    }
+    if (code === 58) {
+      i = parsePseudo(selector, i, tokens, options);
+      continue;
+    }
+    if (code === 124) {
+      i++;
+      const r = readName(selector, i);
+      i = r.end;
+      tokens.push({ type: "tag", name: lowerCaseTagsFlag ? r.value.toLowerCase() : r.value, namespace: "" });
+      continue;
+    }
+    {
+      const r1 = readName(selector, i);
+      i = r1.end;
+      if (i < len && selector.charCodeAt(i) === 124 && selector.charCodeAt(i + 1) !== 61) {
+        i++;
+        const r2 = readName(selector, i);
+        i = r2.end;
+        tokens.push({ type: "tag", name: lowerCaseTagsFlag ? r2.value.toLowerCase() : r2.value, namespace: r1.value });
+      } else {
+        tokens.push({ type: "tag", name: lowerCaseTagsFlag ? r1.value.toLowerCase() : r1.value, namespace: null });
+      }
+    }
+  }
+  if (tokens.length > 0)
+    subselects.push(tokens);
+  return i;
+}
+function parseAttribute(selector, idx, tokens, options, xmlMode, lowerCaseAttrs) {
+  let i = idx + 1;
+  const len = selector.length;
+  let attribute;
+  if (selector.charCodeAt(i) === 124)
+    throw new Error("Empty namespace not supported");
+  if (selector.charCodeAt(i) === 42 && selector.charCodeAt(i + 1) === 124) {
+    i += 2;
+    const r = readName(selector, i);
+    i = r.end;
+    attribute = r.value;
+  } else {
+    const r = readName(selector, i);
+    i = r.end;
+    attribute = r.value;
+    if (selector.charCodeAt(i) === 124 && selector.charCodeAt(i + 1) !== 61) {
+      i++;
+      const r2 = readName(selector, i);
+      i = r2.end;
+      attribute = r2.value;
+    }
+  }
+  i = stripWS(selector, i);
+  let action = "exists";
+  let value = "";
+  let ignoreCase = null;
+  const opCode = selector.charCodeAt(i);
+  if (opCode === 61) {
+    action = "equals";
+    i++;
+  } else if (opCode === 33 && selector.charCodeAt(i + 1) === 61) {
+    action = "not";
+    i += 2;
+  } else {
+    const a = actionFromChar(opCode);
+    if (a !== null && selector.charCodeAt(i + 1) === 61) {
+      action = a;
+      i += 2;
+    }
+  }
+  if (action !== "exists") {
+    i = stripWS(selector, i);
+    const q = selector.charCodeAt(i);
+    if (q === 34 || q === 39) {
+      const end = findEndOfString(selector, i + 1, q);
+      value = unescapeIfNeeded(selector.slice(i + 1, end));
+      i = end + 1;
+    } else {
+      const r = readName(selector, i);
+      value = r.value;
+      i = r.end;
+    }
+    i = stripWS(selector, i);
+    const flag = selector.charCodeAt(i);
+    if (flag === 105 || flag === 73) {
+      ignoreCase = true;
+      i++;
+    } else if (flag === 115 || flag === 83) {
+      ignoreCase = false;
+      i++;
+    }
+  }
+  if (selector.charCodeAt(i) !== 93)
+    throw new Error("Expected ]");
+  i++;
+  if (ignoreCase === null && !xmlMode && ATTRIBUTES_QUIRKS.has(attribute.toLowerCase()))
+    ignoreCase = "quirks";
+  tokens.push({
+    type: "attribute",
+    name: lowerCaseAttrs ? attribute.toLowerCase() : attribute,
+    action,
+    value,
+    namespace: null,
+    ignoreCase
+  });
+  return i;
+}
+function parsePseudo(selector, idx, tokens, options) {
+  if (selector.charCodeAt(idx + 1) === 58) {
+    let i2 = idx + 2;
+    const r2 = readName(selector, i2);
+    i2 = r2.end;
+    const name2 = r2.value.toLowerCase();
+    let data = null;
+    if (selector.charCodeAt(i2) === 40) {
+      const end = findClose(selector, i2);
+      data = selector.slice(i2 + 1, end).trim();
+      i2 = end + 1;
+    }
+    tokens.push({ type: "pseudo-element", name: name2, data });
+    return i2;
+  }
+  let i = idx + 1;
+  const r = readName(selector, i);
+  i = r.end;
+  const name = r.value.toLowerCase();
+  if (selector.charCodeAt(i) === 40) {
+    const end = findClose(selector, i);
+    const inner = selector.slice(i + 1, end);
+    i = end + 1;
+    if (name === "is" || name === "not" || name === "where" || name === "has" || name === "matches" || name === "-moz-any" || name === "-webkit-any") {
+      const sub = [];
+      parseSelectorImpl(sub, inner.trim(), options, 0);
+      tokens.push({ type: "pseudo", name, data: sub });
+    } else {
+      tokens.push({ type: "pseudo", name, data: inner.trim() });
+    }
+  } else {
+    tokens.push({ type: "pseudo", name, data: null });
+  }
+  return i;
+}
+function addTraversal(tokens, type) {
+  if (tokens.length > 0 && tokens[tokens.length - 1].type === "descendant" && type !== "descendant")
+    tokens.pop();
+  if (tokens.length > 0 && tokens[tokens.length - 1].type === type)
+    return;
+  tokens.push({ type });
+}
+function findEndOfString(selector, start, qCode) {
+  let i = start;
+  const len = selector.length;
+  while (i < len) {
+    const c = selector.charCodeAt(i);
+    if (c === 92) {
+      i += 2;
+      continue;
+    }
+    if (c === qCode)
+      return i;
+    i++;
+  }
+  throw new Error("Unterminated string");
+}
+function findClose(selector, openParen) {
+  let depth = 1;
+  let i = openParen + 1;
+  const len = selector.length;
+  while (i < len) {
+    const c = selector.charCodeAt(i);
+    if (c === 92) {
+      i += 2;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      i = findEndOfString(selector, i + 1, c) + 1;
+      continue;
+    }
+    if (c === 40)
+      depth++;
+    else if (c === 41) {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  throw new Error("Unterminated parenthesis");
+}
+// src/what/stringify.ts
+var COMBINATORS = {
+  child: " > ",
+  parent: " < ",
+  sibling: " ~ ",
+  adjacent: " + ",
+  descendant: " ",
+  "column-combinator": " || "
+};
+function stringify(selector) {
+  return selector.map(stringifySegments).join(", ");
+}
+function stringifySegments(tokens) {
+  return tokens.map((t, i) => stringifyOne(t, tokens[i - 1])).join("");
+}
+function stringifyOne(token, _prev) {
+  switch (token.type) {
+    case "tag":
+      return `${nsPrefix(token.namespace)}${escapeIdent(token.name)}`;
+    case "universal":
+      return `${nsPrefix(token.namespace)}*`;
+    case "attribute": {
+      if (token.name === "id" && token.action === "equals" && !token.ignoreCase && !token.namespace)
+        return `#${escapeIdent(token.value)}`;
+      if (token.name === "class" && token.action === "element" && !token.ignoreCase && !token.namespace)
+        return `.${escapeIdent(token.value)}`;
+      let out = `[${nsPrefix(token.namespace)}${escapeIdent(token.name)}`;
+      if (token.action !== "exists") {
+        const op = ACTION_OP[token.action] ?? "=";
+        out += op;
+        out += `"${token.value.replace(/"/g, "\\\"")}"`;
+        if (token.ignoreCase === true)
+          out += " i";
+        else if (token.ignoreCase === false)
+          out += " s";
+      }
+      out += "]";
+      return out;
+    }
+    case "pseudo":
+      if (token.data === null)
+        return `:${token.name}`;
+      if (typeof token.data === "string")
+        return `:${token.name}(${token.data})`;
+      return `:${token.name}(${stringify(token.data)})`;
+    case "pseudo-element":
+      return token.data === null ? `::${token.name}` : `::${token.name}(${token.data})`;
+    case "descendant":
+    case "child":
+    case "parent":
+    case "sibling":
+    case "adjacent":
+    case "column-combinator":
+      return COMBINATORS[token.type] ?? " ";
+  }
+  return "";
+}
+var ACTION_OP = {
+  equals: "=",
+  element: "~=",
+  start: "^=",
+  end: "$=",
+  any: "*=",
+  not: "!=",
+  hyphen: "|="
+};
+function nsPrefix(ns) {
+  if (ns === null)
+    return "";
+  if (ns === "")
+    return "|";
+  return `${escapeIdent(ns)}|`;
+}
+var RE_INVALID_ID_CHAR = /[^\w\u00B0-\uFFFF-]/g;
+function escapeIdent(name) {
+  if (name === "")
+    return "";
+  return name.replace(RE_INVALID_ID_CHAR, (m) => `\\${m}`);
+}
+// src/what/traversal.ts
+var TRAVERSAL_TYPES = new Set(["adjacent", "child", "descendant", "parent", "sibling", "column-combinator"]);
+function isTraversal(token) {
+  return TRAVERSAL_TYPES.has(token.type);
+}
+// src/what/types.ts
+var IgnoreCaseMode = {
+  Unknown: null,
+  QuirksMode: "quirks",
+  IgnoreCase: true,
+  CaseSensitive: false
+};
+export {
+  stringify,
+  parse,
+  isTraversal,
+  IgnoreCaseMode
+};

package/dist/what/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ParseOptions, Selector } from './types';
+export declare function parse(selector: string, options?: ParseOptions): Selector[][];

package/dist/what/stringify.d.ts

@@ -0,0 +1,2 @@
+import type { Selector } from './types';
+export declare function stringify(selector: Selector[][]): string;

package/dist/what/traversal.d.ts

@@ -0,0 +1,3 @@
+import type { Selector } from './types';
+/** True when `token` is a traversal/combinator segment (vs. simple selector). */
+export declare function isTraversal(token: Selector): boolean;

package/dist/what/types.d.ts

@@ -0,0 +1,66 @@
+export declare const IgnoreCaseMode: Readonly<Record<string, true | false | 'quirks' | null>>;
+export declare interface AttributeSelectorNode {
+  type: 'attribute'
+  name: string
+  action: AttributeAction
+  value: string
+  namespace: string | null
+  ignoreCase: IgnoreCase
+}
+export declare interface TagSelectorNode {
+  type: 'tag'
+  name: string
+  namespace: string | null
+}
+export declare interface UniversalSelectorNode {
+  type: 'universal'
+  namespace: string | null
+}
+export declare interface PseudoSelectorNode {
+  type: 'pseudo'
+  name: string
+  data: string | Selector[][] | null
+}
+export declare interface PseudoElementNode {
+  type: 'pseudo-element'
+  name: string
+  data: string | null
+}
+export declare interface TraversalNode {
+  type: 'adjacent' | 'child' | 'descendant' | 'parent' | 'sibling' | 'column-combinator'
+}
+export declare interface ParseOptions {
+  xmlMode?: boolean
+  lowerCaseAttributeNames?: boolean
+  lowerCaseTags?: boolean
+}
+/**
+ * Selector AST mirroring css-what v6 — the segment-list-of-lists shape
+ * `parse(selector)` returns. Compatible with css-select consumers.
+ */
+export type SelectorType = | 'attribute'
+    | 'pseudo'
+    | 'pseudo-element'
+    | 'tag'
+    | 'universal'
+    | 'adjacent'
+    | 'child'
+    | 'descendant'
+    | 'parent'
+    | 'sibling'
+    | 'column-combinator';
+export type AttributeAction = | 'any'
+    | 'element'
+    | 'end'
+    | 'equals'
+    | 'exists'
+    | 'hyphen'
+    | 'not'
+    | 'start';
+export type IgnoreCase = boolean | 'quirks' | null;
+export type Selector = | AttributeSelectorNode
+    | TagSelectorNode
+    | UniversalSelectorNode
+    | PseudoSelectorNode
+    | PseudoElementNode
+    | TraversalNode;