@jinmi/ui 0.0.0-stage → 6.0.2

package/es/node_modules/.pnpm/unist-util-visit@5.1.0/node_modules/unist-util-visit/lib/index.mjs

@@ -0,0 +1,289 @@
+import { SKIP as SKIP$1, visitParents } from "unist-util-visit-parents";
+//#region node_modules/.pnpm/unist-util-visit@5.1.0/node_modules/unist-util-visit/lib/index.js
+/**
+* @import {Node as UnistNode, Parent as UnistParent} from 'unist'
+* @import {VisitorResult} from 'unist-util-visit-parents'
+*/
+/**
+* @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+*   Test from `unist-util-is`.
+*
+*   Note: we have remove and add `undefined`, because otherwise when generating
+*   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+*   which doesn’t work when publishing on npm.
+*/
+/**
+* @typedef {(
+*   Fn extends (value: any) => value is infer Thing
+*   ? Thing
+*   : Fallback
+* )} Predicate
+*   Get the value of a type guard `Fn`.
+* @template Fn
+*   Value; typically function that is a type guard (such as `(x): x is Y`).
+* @template Fallback
+*   Value to yield if `Fn` is not a type guard.
+*/
+/**
+* @typedef {(
+*   Check extends null | undefined // No test.
+*   ? Value
+*   : Value extends {type: Check} // String (type) test.
+*   ? Value
+*   : Value extends Check // Partial test.
+*   ? Value
+*   : Check extends Function // Function test.
+*   ? Predicate<Check, Value> extends Value
+*     ? Predicate<Check, Value>
+*     : never
+*   : never // Some other test?
+* )} MatchesOne
+*   Check whether a node matches a primitive check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test, but not arrays.
+*/
+/**
+* @typedef {(
+*   Check extends ReadonlyArray<any>
+*   ? MatchesOne<Value, Check[number]>
+*   : MatchesOne<Value, Check>
+* )} Matches
+*   Check whether a node matches a check in the type system.
+* @template Value
+*   Value; typically unist `Node`.
+* @template Check
+*   Value; typically `unist-util-is`-compatible test.
+*/
+/**
+* @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+*   Number; capped reasonably.
+*/
+/**
+* @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+*   Increment a number in the type system.
+* @template {Uint} [I=0]
+*   Index.
+*/
+/**
+* @typedef {(
+*   Node extends UnistParent
+*   ? Node extends {children: Array<infer Children>}
+*     ? Child extends Children ? Node : never
+*     : never
+*   : never
+* )} InternalParent
+*   Collect nodes that can be parents of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent
+*   Collect nodes in `Tree` that can be parents of `Child`.
+* @template {UnistNode} Tree
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+*/
+/**
+* @typedef {(
+*   Depth extends Max
+*   ? never
+*   :
+*     | InternalParent<Node, Child>
+*     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
+* )} InternalAncestor
+*   Collect nodes in `Tree` that can be ancestors of `Child`.
+* @template {UnistNode} Node
+*   All node types in a tree.
+* @template {UnistNode} Child
+*   Node to search for.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @typedef {(
+*   Tree extends UnistParent
+*     ? Depth extends Max
+*       ? Tree
+*       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+*     : Tree
+* )} InclusiveDescendant
+*   Collect all (inclusive) descendants of `Tree`.
+*
+*   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+*   > recurse without actually running into an infinite loop, which the
+*   > previous version did.
+*   >
+*   > Practically, a max of `2` is typically enough assuming a `Root` is
+*   > passed, but it doesn’t improve performance.
+*   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+*   > Using up to `10` doesn’t hurt or help either.
+* @template {UnistNode} Tree
+*   Tree type.
+* @template {Uint} [Max=10]
+*   Max; searches up to this depth.
+* @template {Uint} [Depth=0]
+*   Current depth.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given).
+*
+*   Visitors are free to transform `node`.
+*   They can also transform `parent`.
+*
+*   Replacing `node` itself, if `SKIP` is not returned, still causes its
+*   descendants to be walked (which is a bug).
+*
+*   When adding or removing previous siblings of `node` (or next siblings, in
+*   case of reverse), the `Visitor` should return a new `Index` to specify the
+*   sibling to traverse after `node` is traversed.
+*   Adding or removing next siblings of `node` (or previous siblings, in case
+*   of reverse) is handled as expected without needing to return a new `Index`.
+*
+*   Removing the children property of `parent` still results in them being
+*   traversed.
+* @param {Visited} node
+*   Found node.
+* @param {Visited extends UnistNode ? number | undefined : never} index
+*   Index of `node` in `parent`.
+* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+*   Parent of `node`.
+* @returns {VisitorResult}
+*   What to do next.
+*
+*   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
+*   An `Action` is treated as a tuple of `[Action]`.
+*
+*   Passing a tuple back only makes sense if the `Action` is `SKIP`.
+*   When the `Action` is `EXIT`, that action can be returned.
+*   When the `Action` is `CONTINUE`, `Index` can be returned.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
+*   Build a typed `Visitor` function from a node and all possible parents.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Visited
+*   Node type.
+* @template {UnistParent} Ancestor
+*   Parent type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromMatch<
+*     Matches<Descendant, Check>,
+*     Extract<Descendant, UnistParent>
+*   >
+* )} BuildVisitorFromDescendants
+*   Build a typed `Visitor` function from a list of descendants and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} Descendant
+*   Node type.
+* @template {Test} Check
+*   Test type.
+*/
+/**
+* @typedef {(
+*   BuildVisitorFromDescendants<
+*     InclusiveDescendant<Tree>,
+*     Check
+*   >
+* )} BuildVisitor
+*   Build a typed `Visitor` function from a tree and a test.
+*
+*   It will infer which values are passed as `node` and which as `parent`.
+* @template {UnistNode} [Tree=UnistNode]
+*   Node type.
+* @template {Test} [Check=Test]
+*   Test type.
+*/
+/**
+* Visit nodes.
+*
+* This algorithm performs *depth-first* *tree traversal* in *preorder*
+* (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+*
+* You can choose for which nodes `visitor` is called by passing a `test`.
+* For complex tests, you should test yourself in `visitor`, as it will be
+* faster and will have improved type information.
+*
+* Walking the tree is an intensive task.
+* Make use of the return values of the visitor when possible.
+* Instead of walking a tree multiple times, walk it once, use `unist-util-is`
+* to check if a node matches, and then perform different operations.
+*
+* You can change the tree.
+* See `Visitor` for more info.
+*
+* @overload
+* @param {Tree} tree
+* @param {Check} check
+* @param {BuildVisitor<Tree, Check>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @overload
+* @param {Tree} tree
+* @param {BuildVisitor<Tree>} visitor
+* @param {boolean | null | undefined} [reverse]
+* @returns {undefined}
+*
+* @param {UnistNode} tree
+*   Tree to traverse.
+* @param {Visitor | Test} testOrVisitor
+*   `unist-util-is`-compatible test (optional, omit to pass a visitor).
+* @param {Visitor | boolean | null | undefined} [visitorOrReverse]
+*   Handle each node (when test is omitted, pass `reverse`).
+* @param {boolean | null | undefined} [maybeReverse=false]
+*   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+* @returns {undefined}
+*   Nothing.
+*
+* @template {UnistNode} Tree
+*   Node type.
+* @template {Test} Check
+*   `unist-util-is`-compatible test.
+*/
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+	/** @type {boolean | null | undefined} */
+	let reverse;
+	/** @type {Test} */
+	let test;
+	/** @type {Visitor} */
+	let visitor;
+	if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
+		test = void 0;
+		visitor = testOrVisitor;
+		reverse = visitorOrReverse;
+	} else {
+		test = testOrVisitor;
+		visitor = visitorOrReverse;
+		reverse = maybeReverse;
+	}
+	visitParents(tree, test, overload, reverse);
+	/**
+	* @param {UnistNode} node
+	* @param {Array<UnistParent>} parents
+	*/
+	function overload(node, parents) {
+		const parent = parents[parents.length - 1];
+		const index = parent ? parent.children.indexOf(node) : void 0;
+		return visitor(node, index, parent);
+	}
+}
+//#endregion
+export { SKIP$1 as SKIP, visit };
+
+//# sourceMappingURL=index.mjs.map

package/es/node_modules/.pnpm/unist-util-visit@5.1.0/node_modules/unist-util-visit/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../../node_modules/.pnpm/unist-util-visit@5.1.0/node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n * @import {VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<any>\n *   ? MatchesOne<Value, Check[number]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n"],"ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqRA,SAAgB,MAAM,MAAM,eAAe,kBAAkB,cAAc;;CAEzE,IAAI;;CAEJ,IAAI;;CAEJ,IAAI;CAEJ,IACE,OAAO,kBAAkB,cACzB,OAAO,qBAAqB,YAC5B;EACA,OAAO,KAAA;EACP,UAAU;EACV,UAAU;CACZ,OAAO;EAEL,OAAO;EAEP,UAAU;EACV,UAAU;CACZ;CAEA,aAAa,MAAM,MAAM,UAAU,OAAO;;;;;CAM1C,SAAS,SAAS,MAAM,SAAS;EAC/B,MAAM,SAAS,QAAQ,QAAQ,SAAS;EACxC,MAAM,QAAQ,SAAS,OAAO,SAAS,QAAQ,IAAI,IAAI,KAAA;EACvD,OAAO,QAAQ,MAAM,OAAO,MAAM;CACpC;AACF"}

package/es/static-css/baseline.d.mts

@@ -0,0 +1,6 @@
+import { AntdProbeName } from "./registry.mjs";
+//#region src/static-css/baseline.d.ts
+declare const lobeUiAntdBaseline: AntdProbeName[];
+//#endregion
+export { lobeUiAntdBaseline };
+//# sourceMappingURL=baseline.d.mts.map

package/es/static-css/baseline.mjs

@@ -0,0 +1,31 @@
+//#region src/static-css/baseline.ts
+const lobeUiAntdBaseline = [
+	"alert",
+	"anchor",
+	"app",
+	"auto-complete",
+	"avatar",
+	"button",
+	"collapse",
+	"date-picker",
+	"divider",
+	"drawer",
+	"dropdown",
+	"form",
+	"input",
+	"input-number",
+	"input-textarea",
+	"menu",
+	"modal",
+	"segmented",
+	"select",
+	"slider",
+	"tabs",
+	"tag",
+	"tag-preset",
+	"tag-status"
+];
+//#endregion
+export { lobeUiAntdBaseline };
+
+//# sourceMappingURL=baseline.mjs.map

package/es/static-css/baseline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.mjs","names":[],"sources":["../../src/static-css/baseline.ts"],"sourcesContent":["import type { AntdProbeName } from './registry';\n\n// The antd components @jinmi/ui internals can render. Kept in sync with the\n// source tree by baseline.test.ts — a failure there means this list must change.\nexport const lobeUiAntdBaseline: AntdProbeName[] = [\n  'alert',\n  'anchor',\n  'app',\n  'auto-complete',\n  'avatar',\n  'button',\n  'collapse',\n  'date-picker',\n  'divider',\n  'drawer',\n  'dropdown',\n  'form',\n  'input',\n  'input-number',\n  'input-textarea',\n  'menu',\n  'modal',\n  'segmented',\n  'select',\n  'slider',\n  'tabs',\n  'tag',\n  'tag-preset',\n  'tag-status',\n];\n"],"mappings":";AAIA,MAAa,qBAAsC;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/es/static-css/buildAntdStaticCss.d.mts

@@ -0,0 +1,31 @@
+import { AntdProbeName } from "./registry.mjs";
+import { ScanAntdUsageOptions } from "./scan.mjs";
+import { ReactElement } from "react";
+import { ThemeConfig } from "antd";
+//#region src/static-css/buildAntdStaticCss.d.ts
+interface AntdStaticCssOptions {
+  /** escape hatch for render paths the registry has no probe for */
+  customProbes?: [name: string, render: () => ReactElement][];
+  /** extra probes on top of 'auto' scan results */
+  extraIncluded?: AntdProbeName[];
+  hrefTemplate?: (hash: string) => string;
+  included?: 'auto' | AntdProbeName[];
+  scan?: ScanAntdUsageOptions;
+  /** must equal the ConfigProvider theme used at SSR — token hash decides styleKeys matching */
+  theme?: ThemeConfig;
+}
+interface AntdStaticCssPayload {
+  css: string;
+  failedProbes: string[];
+  hash: string;
+  href: string;
+  probes: string[];
+  styleKeys: string[];
+  /** antd exports found by 'auto' scan that no registry probe covers */
+  unmatchedComponents: string[];
+}
+declare const createProbeAntdTheme: () => ThemeConfig;
+declare const buildAntdStaticCss: (options?: AntdStaticCssOptions) => AntdStaticCssPayload;
+//#endregion
+export { AntdStaticCssOptions, AntdStaticCssPayload, buildAntdStaticCss, createProbeAntdTheme };
+//# sourceMappingURL=buildAntdStaticCss.d.mts.map

package/es/static-css/buildAntdStaticCss.mjs

@@ -0,0 +1,71 @@
+import { createLobeAntdTheme } from "../styles/theme/antdTheme.mjs";
+import { lobeUiAntdBaseline } from "./baseline.mjs";
+import { hashCss } from "./hash.mjs";
+import { antdProbeNames, antdProbeRegistry, expandComponentsToProbes } from "./registry.mjs";
+import { scanAntdUsage } from "./scan.mjs";
+import { styleKeysOf } from "./shared.mjs";
+import { createElement } from "react";
+import { StyleProvider } from "antd-style";
+import { ConfigProvider, theme } from "antd";
+import { createCache, extractStyle } from "@ant-design/cssinjs";
+import { renderToString } from "react-dom/server";
+//#region src/static-css/buildAntdStaticCss.ts
+const createProbeAntdTheme = () => {
+	const config = createLobeAntdTheme({ appearance: "light" });
+	return {
+		...config,
+		algorithm: [theme.defaultAlgorithm, config.algorithm ?? []].flat()
+	};
+};
+const resolveProbes = (options) => {
+	const { included = "auto", extraIncluded = [], customProbes = [], scan } = options;
+	const names = /* @__PURE__ */ new Set();
+	const unmatchedComponents = [];
+	if (included === "auto") {
+		const usage = scanAntdUsage(scan);
+		if (usage.wildcard) for (const name of antdProbeNames) names.add(name);
+		else {
+			const expanded = expandComponentsToProbes(usage.components);
+			for (const name of expanded.probes) names.add(name);
+			unmatchedComponents.push(...expanded.unmatched);
+		}
+		if (usage.importsLobeUi) for (const name of lobeUiAntdBaseline) names.add(name);
+	} else for (const name of included) names.add(name);
+	for (const name of extraIncluded) names.add(name);
+	return {
+		probes: [...[...names].sort().map((name) => [name, antdProbeRegistry[name].render]), ...customProbes],
+		unmatchedComponents
+	};
+};
+const buildAntdStaticCss = (options = {}) => {
+	const { theme = createProbeAntdTheme(), hrefTemplate = (hash) => `/antd.css?v=${hash}` } = options;
+	const { probes, unmatchedComponents } = resolveProbes(options);
+	const cache = createCache();
+	const failedProbes = [];
+	for (const [name, probe] of probes) try {
+		renderToString(createElement(StyleProvider, {
+			cache,
+			children: createElement(ConfigProvider, { theme }, probe())
+		}));
+	} catch {
+		failedProbes.push(name);
+	}
+	const css = extractStyle(cache, {
+		plain: true,
+		types: ["style"]
+	});
+	const hash = hashCss(css);
+	return {
+		css,
+		failedProbes,
+		hash,
+		href: hrefTemplate(hash),
+		probes: probes.map(([name]) => name),
+		styleKeys: styleKeysOf(cache).sort(),
+		unmatchedComponents
+	};
+};
+//#endregion
+export { buildAntdStaticCss, createProbeAntdTheme };
+
+//# sourceMappingURL=buildAntdStaticCss.mjs.map

package/es/static-css/buildAntdStaticCss.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildAntdStaticCss.mjs","names":["antdTheme","extractCssinjsStyle"],"sources":["../../src/static-css/buildAntdStaticCss.ts"],"sourcesContent":["import { createCache, extractStyle as extractCssinjsStyle } from '@ant-design/cssinjs';\r\nimport type { ThemeConfig } from 'antd';\r\nimport { ConfigProvider, theme as antdTheme } from 'antd';\r\nimport { StyleProvider } from 'antd-style';\r\nimport type { ReactElement } from 'react';\r\nimport { createElement } from 'react';\r\nimport { renderToString } from 'react-dom/server';\r\n\r\nimport { createLobeAntdTheme } from '@/styles/theme/antdTheme';\r\n\r\nimport { lobeUiAntdBaseline } from './baseline';\r\nimport { hashCss } from './hash';\r\nimport type { AntdProbeName } from './registry';\r\nimport { antdProbeNames, antdProbeRegistry, expandComponentsToProbes } from './registry';\r\nimport type { ScanAntdUsageOptions } from './scan';\r\nimport { scanAntdUsage } from './scan';\r\nimport { styleKeysOf } from './shared';\r\n\r\nexport interface AntdStaticCssOptions {\r\n  /** escape hatch for render paths the registry has no probe for */\r\n  customProbes?: [name: string, render: () => ReactElement][];\r\n  /** extra probes on top of 'auto' scan results */\r\n  extraIncluded?: AntdProbeName[];\r\n  hrefTemplate?: (hash: string) => string;\r\n  included?: 'auto' | AntdProbeName[];\r\n  scan?: ScanAntdUsageOptions;\r\n  /** must equal the ConfigProvider theme used at SSR — token hash decides styleKeys matching */\r\n  theme?: ThemeConfig;\r\n}\r\n\r\nexport interface AntdStaticCssPayload {\r\n  css: string;\r\n  failedProbes: string[];\r\n  hash: string;\r\n  href: string;\r\n  probes: string[];\r\n  styleKeys: string[];\r\n  /** antd exports found by 'auto' scan that no registry probe covers */\r\n  unmatchedComponents: string[];\r\n}\r\n\r\nexport const createProbeAntdTheme = (): ThemeConfig => {\r\n  const config = createLobeAntdTheme({ appearance: 'light' });\r\n  return {\r\n    ...config,\r\n    algorithm: [antdTheme.defaultAlgorithm, config.algorithm ?? []].flat(),\r\n  };\r\n};\r\n\r\nconst resolveProbes = (options: AntdStaticCssOptions) => {\r\n  const { included = 'auto', extraIncluded = [], customProbes = [], scan } = options;\r\n\r\n  const names = new Set<AntdProbeName>();\r\n  const unmatchedComponents: string[] = [];\r\n\r\n  if (included === 'auto') {\r\n    const usage = scanAntdUsage(scan);\r\n    if (usage.wildcard) {\r\n      for (const name of antdProbeNames) names.add(name);\r\n    } else {\r\n      const expanded = expandComponentsToProbes(usage.components);\r\n      for (const name of expanded.probes) names.add(name);\r\n      unmatchedComponents.push(...expanded.unmatched);\r\n    }\r\n    if (usage.importsLobeUi) for (const name of lobeUiAntdBaseline) names.add(name);\r\n  } else {\r\n    for (const name of included) names.add(name);\r\n  }\r\n\r\n  for (const name of extraIncluded) names.add(name);\r\n\r\n  const probes: [string, () => ReactElement][] = [...names]\r\n    .sort()\r\n    .map((name) => [name, antdProbeRegistry[name].render]);\r\n\r\n  return { probes: [...probes, ...customProbes], unmatchedComponents };\r\n};\r\n\r\nexport const buildAntdStaticCss = (options: AntdStaticCssOptions = {}): AntdStaticCssPayload => {\r\n  const { theme = createProbeAntdTheme(), hrefTemplate = (hash) => `/antd.css?v=${hash}` } =\r\n    options;\r\n\r\n  const { probes, unmatchedComponents } = resolveProbes(options);\r\n\r\n  const cache = createCache();\r\n  const failedProbes: string[] = [];\r\n\r\n  for (const [name, probe] of probes) {\r\n    try {\r\n      renderToString(\r\n        createElement(StyleProvider, {\r\n          cache,\r\n          children: createElement(ConfigProvider, { theme }, probe()),\r\n        }),\r\n      );\r\n    } catch {\r\n      failedProbes.push(name);\r\n    }\r\n  }\r\n\r\n  const css = extractCssinjsStyle(cache, { plain: true, types: ['style'] });\r\n  const hash = hashCss(css);\r\n\r\n  return {\r\n    css,\r\n    failedProbes,\r\n    hash,\r\n    href: hrefTemplate(hash),\r\n    probes: probes.map(([name]) => name),\r\n    styleKeys: styleKeysOf(cache as unknown as { cache: Map<string, unknown> }).sort(),\r\n    unmatchedComponents,\r\n  };\r\n};\r\n"],"mappings":";;;;;;;;;;;;AAyCA,MAAa,6BAA0C;CACrD,MAAM,SAAS,oBAAoB,EAAE,YAAY,QAAQ,CAAC;CAC1D,OAAO;EACL,GAAG;EACH,WAAW,CAACA,MAAU,kBAAkB,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK;CACvE;AACF;AAEA,MAAM,iBAAiB,YAAkC;CACvD,MAAM,EAAE,WAAW,QAAQ,gBAAgB,CAAC,GAAG,eAAe,CAAC,GAAG,SAAS;CAE3E,MAAM,wBAAQ,IAAI,IAAmB;CACrC,MAAM,sBAAgC,CAAC;CAEvC,IAAI,aAAa,QAAQ;EACvB,MAAM,QAAQ,cAAc,IAAI;EAChC,IAAI,MAAM,UACR,KAAK,MAAM,QAAQ,gBAAgB,MAAM,IAAI,IAAI;OAC5C;GACL,MAAM,WAAW,yBAAyB,MAAM,UAAU;GAC1D,KAAK,MAAM,QAAQ,SAAS,QAAQ,MAAM,IAAI,IAAI;GAClD,oBAAoB,KAAK,GAAG,SAAS,SAAS;EAChD;EACA,IAAI,MAAM,eAAe,KAAK,MAAM,QAAQ,oBAAoB,MAAM,IAAI,IAAI;CAChF,OACE,KAAK,MAAM,QAAQ,UAAU,MAAM,IAAI,IAAI;CAG7C,KAAK,MAAM,QAAQ,eAAe,MAAM,IAAI,IAAI;CAMhD,OAAO;EAAE,QAAQ,CAAC,GAJ6B,CAAC,GAAG,KAAK,CAAC,CACtD,KAAK,CAAC,CACN,KAAK,SAAS,CAAC,MAAM,kBAAkB,KAAK,CAAC,MAAM,CAE5B,GAAG,GAAG,YAAY;EAAG;CAAoB;AACrE;AAEA,MAAa,sBAAsB,UAAgC,CAAC,MAA4B;CAC9F,MAAM,EAAE,QAAQ,qBAAqB,GAAG,gBAAgB,SAAS,eAAe,WAC9E;CAEF,MAAM,EAAE,QAAQ,wBAAwB,cAAc,OAAO;CAE7D,MAAM,QAAQ,YAAY;CAC1B,MAAM,eAAyB,CAAC;CAEhC,KAAK,MAAM,CAAC,MAAM,UAAU,QAC1B,IAAI;EACF,eACE,cAAc,eAAe;GAC3B;GACA,UAAU,cAAc,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAAC;EAC5D,CAAC,CACH;CACF,QAAQ;EACN,aAAa,KAAK,IAAI;CACxB;CAGF,MAAM,MAAMC,aAAoB,OAAO;EAAE,OAAO;EAAM,OAAO,CAAC,OAAO;CAAE,CAAC;CACxE,MAAM,OAAO,QAAQ,GAAG;CAExB,OAAO;EACL;EACA;EACA;EACA,MAAM,aAAa,IAAI;EACvB,QAAQ,OAAO,KAAK,CAAC,UAAU,IAAI;EACnC,WAAW,YAAY,KAAmD,CAAC,CAAC,KAAK;EACjF;CACF;AACF"}

package/es/static-css/emit/index.d.mts

@@ -0,0 +1,18 @@
+import { AntdStaticCssOptions, AntdStaticCssPayload } from "../buildAntdStaticCss.mjs";
+import { ThemeVarsCssOptions, ThemeVarsCssPayload } from "../themeVars.mjs";
+//#region src/static-css/emit/index.d.ts
+interface EmitStaticCssOptions {
+  antd?: AntdStaticCssOptions | false;
+  manifestPath?: string;
+  outDir: string;
+  themeVars?: ThemeVarsCssOptions | false;
+}
+interface EmitStaticCssResult {
+  antd?: AntdStaticCssPayload;
+  files: string[];
+  themeVars?: ThemeVarsCssPayload;
+}
+declare const emitStaticCssAssets: (options: EmitStaticCssOptions) => Promise<EmitStaticCssResult>;
+//#endregion
+export { EmitStaticCssOptions, EmitStaticCssResult, emitStaticCssAssets };
+//# sourceMappingURL=index.d.mts.map

package/es/static-css/emit/index.mjs

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/static-css/emit/index.ts
+process.env.NODE_ENV = "production";
+const emitStaticCssAssets = async (options) => {
+	const { outDir, manifestPath = path.join(outDir, "static-css.manifest.json") } = options;
+	await mkdir(outDir, { recursive: true });
+	const result = { files: [] };
+	const manifest = {};
+	if (options.antd !== false) {
+		const { buildAntdStaticCss } = await import("../buildAntdStaticCss.mjs");
+		const payload = buildAntdStaticCss(options.antd);
+		const file = path.join(outDir, "antd.css");
+		await writeFile(file, payload.css, "utf8");
+		result.antd = payload;
+		result.files.push(file);
+		manifest.antd = {
+			hash: payload.hash,
+			href: payload.href,
+			styleKeys: payload.styleKeys
+		};
+	}
+	if (options.themeVars !== false) {
+		const { buildThemeVarsCss } = await import("../themeVars.mjs");
+		const payload = buildThemeVarsCss(options.themeVars);
+		const file = path.join(outDir, "theme-vars.css");
+		await writeFile(file, payload.css, "utf8");
+		result.themeVars = payload;
+		result.files.push(file);
+		manifest.themeVars = {
+			hash: payload.hash,
+			href: payload.href
+		};
+	}
+	await writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+	result.files.push(manifestPath);
+	return result;
+};
+//#endregion
+export { emitStaticCssAssets };
+
+//# sourceMappingURL=index.mjs.map

package/es/static-css/emit/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/static-css/emit/index.ts"],"sourcesContent":["// react-dom/server, @ant-design/cssinjs and antd-style pick their dev/prod flavor\r\n// at import time and the dev flavor emits different CSS, so production must be\r\n// forced before any React/antd module loads — hence this entry has no static\r\n// imports of them and must be imported before anything that does.\r\nimport { mkdir, writeFile } from 'node:fs/promises';\r\nimport path from 'node:path';\r\n\r\nimport type { AntdStaticCssOptions, AntdStaticCssPayload } from '../buildAntdStaticCss';\r\nimport type { ThemeVarsCssOptions, ThemeVarsCssPayload } from '../themeVars';\r\n\r\nprocess.env.NODE_ENV = 'production';\r\n\r\nexport interface EmitStaticCssOptions {\r\n  antd?: AntdStaticCssOptions | false;\r\n  manifestPath?: string;\r\n  outDir: string;\r\n  themeVars?: ThemeVarsCssOptions | false;\r\n}\r\n\r\nexport interface EmitStaticCssResult {\r\n  antd?: AntdStaticCssPayload;\r\n  files: string[];\r\n  themeVars?: ThemeVarsCssPayload;\r\n}\r\n\r\nexport const emitStaticCssAssets = async (\r\n  options: EmitStaticCssOptions,\r\n): Promise<EmitStaticCssResult> => {\r\n  const { outDir, manifestPath = path.join(outDir, 'static-css.manifest.json') } = options;\r\n\r\n  await mkdir(outDir, { recursive: true });\r\n\r\n  const result: EmitStaticCssResult = { files: [] };\r\n  const manifest: Record<string, unknown> = {};\r\n\r\n  if (options.antd !== false) {\r\n    const { buildAntdStaticCss } = await import('../buildAntdStaticCss');\r\n    const payload = buildAntdStaticCss(options.antd);\r\n    const file = path.join(outDir, 'antd.css');\r\n    await writeFile(file, payload.css, 'utf8');\r\n    result.antd = payload;\r\n    result.files.push(file);\r\n    manifest.antd = { hash: payload.hash, href: payload.href, styleKeys: payload.styleKeys };\r\n  }\r\n\r\n  if (options.themeVars !== false) {\r\n    const { buildThemeVarsCss } = await import('../themeVars');\r\n    const payload = buildThemeVarsCss(options.themeVars);\r\n    const file = path.join(outDir, 'theme-vars.css');\r\n    await writeFile(file, payload.css, 'utf8');\r\n    result.themeVars = payload;\r\n    result.files.push(file);\r\n    manifest.themeVars = { hash: payload.hash, href: payload.href };\r\n  }\r\n\r\n  await writeFile(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');\r\n  result.files.push(manifestPath);\r\n\r\n  return result;\r\n};\r\n"],"mappings":";;;AAUA,QAAQ,IAAI,WAAW;AAevB,MAAa,sBAAsB,OACjC,YACiC;CACjC,MAAM,EAAE,QAAQ,eAAe,KAAK,KAAK,QAAQ,0BAA0B,MAAM;CAEjF,MAAM,MAAM,QAAQ,EAAE,WAAW,KAAK,CAAC;CAEvC,MAAM,SAA8B,EAAE,OAAO,CAAC,EAAE;CAChD,MAAM,WAAoC,CAAC;CAE3C,IAAI,QAAQ,SAAS,OAAO;EAC1B,MAAM,EAAE,uBAAuB,MAAM,OAAO;EAC5C,MAAM,UAAU,mBAAmB,QAAQ,IAAI;EAC/C,MAAM,OAAO,KAAK,KAAK,QAAQ,UAAU;EACzC,MAAM,UAAU,MAAM,QAAQ,KAAK,MAAM;EACzC,OAAO,OAAO;EACd,OAAO,MAAM,KAAK,IAAI;EACtB,SAAS,OAAO;GAAE,MAAM,QAAQ;GAAM,MAAM,QAAQ;GAAM,WAAW,QAAQ;EAAU;CACzF;CAEA,IAAI,QAAQ,cAAc,OAAO;EAC/B,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,UAAU,kBAAkB,QAAQ,SAAS;EACnD,MAAM,OAAO,KAAK,KAAK,QAAQ,gBAAgB;EAC/C,MAAM,UAAU,MAAM,QAAQ,KAAK,MAAM;EACzC,OAAO,YAAY;EACnB,OAAO,MAAM,KAAK,IAAI;EACtB,SAAS,YAAY;GAAE,MAAM,QAAQ;GAAM,MAAM,QAAQ;EAAK;CAChE;CAEA,MAAM,UAAU,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC,GAAG,MAAM;CACvE,OAAO,MAAM,KAAK,YAAY;CAE9B,OAAO;AACT"}

package/es/static-css/hash.mjs

@@ -0,0 +1,7 @@
+import { createHash } from "node:crypto";
+//#region src/static-css/hash.ts
+const hashCss = (css) => createHash("sha256").update(css).digest("hex").slice(0, 8);
+//#endregion
+export { hashCss };
+
+//# sourceMappingURL=hash.mjs.map

package/es/static-css/hash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.mjs","names":[],"sources":["../../src/static-css/hash.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\r\n\r\nexport const hashCss = (css: string): string =>\r\n  createHash('sha256').update(css).digest('hex').slice(0, 8);\r\n"],"mappings":";;AAEA,MAAa,WAAW,QACtB,WAAW,QAAQ,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC"}

package/es/static-css/index.d.mts

@@ -0,0 +1,6 @@
+import { AntdProbeDef, AntdProbeName, ExpandedProbes, antdProbeNames, antdProbeRegistry, expandComponentsToProbes, nonProbeAntdExports } from "./registry.mjs";
+import { AntdUsageScanResult, ScanAntdUsageOptions, scanAntdUsage } from "./scan.mjs";
+import { AntdStaticCssOptions, AntdStaticCssPayload, buildAntdStaticCss, createProbeAntdTheme } from "./buildAntdStaticCss.mjs";
+import { ThemeVarsCssOptions, ThemeVarsCssPayload, buildThemeVarsCss } from "./themeVars.mjs";
+import { lobeUiAntdBaseline } from "./baseline.mjs";
+export { type AntdProbeDef, type AntdProbeName, type AntdStaticCssOptions, type AntdStaticCssPayload, type AntdUsageScanResult, type ExpandedProbes, type ScanAntdUsageOptions, type ThemeVarsCssOptions, type ThemeVarsCssPayload, antdProbeNames, antdProbeRegistry, buildAntdStaticCss, buildThemeVarsCss, createProbeAntdTheme, expandComponentsToProbes, lobeUiAntdBaseline, nonProbeAntdExports, scanAntdUsage };

package/es/static-css/index.d.ts

@@ -0,0 +1 @@
+export * from './index.d.mts';

package/es/static-css/index.js

@@ -0,0 +1 @@
+export * from './index.mjs';

package/es/static-css/index.mjs

@@ -0,0 +1,6 @@
+import { lobeUiAntdBaseline } from "./baseline.mjs";
+import { antdProbeNames, antdProbeRegistry, expandComponentsToProbes, nonProbeAntdExports } from "./registry.mjs";
+import { scanAntdUsage } from "./scan.mjs";
+import { buildAntdStaticCss, createProbeAntdTheme } from "./buildAntdStaticCss.mjs";
+import { buildThemeVarsCss } from "./themeVars.mjs";
+export { antdProbeNames, antdProbeRegistry, buildAntdStaticCss, buildThemeVarsCss, createProbeAntdTheme, expandComponentsToProbes, lobeUiAntdBaseline, nonProbeAntdExports, scanAntdUsage };

package/es/static-css/registry.d.mts

@@ -0,0 +1,20 @@
+import { ReactElement } from "react";
+//#region src/static-css/registry.d.ts
+interface AntdProbeDef {
+  /** antd export name whose usage activates this probe during auto scan */
+  detect: string;
+  render: () => ReactElement;
+}
+declare const PROBE_NAMES: readonly ["alert", "anchor", "app", "auto-complete", "avatar", "badge", "breadcrumb", "button", "card", "checkbox", "collapse", "color-picker", "date-picker", "divider", "drawer", "dropdown", "empty", "flex", "float-button", "form", "grid-col", "grid-row", "image", "input", "input-number", "input-textarea", "mentions", "menu", "modal", "pagination", "popover", "progress", "qrcode", "radio", "rate", "segmented", "select", "skeleton", "slider", "space", "spin", "steps", "switch", "table", "tabs", "tag", "tag-preset", "tag-status", "tooltip", "tree", "typography", "upload"];
+type AntdProbeName = (typeof PROBE_NAMES)[number];
+declare const antdProbeNames: AntdProbeName[];
+declare const antdProbeRegistry: Record<AntdProbeName, AntdProbeDef>;
+declare const nonProbeAntdExports: Set<string>;
+interface ExpandedProbes {
+  probes: AntdProbeName[];
+  unmatched: string[];
+}
+declare const expandComponentsToProbes: (components: Iterable<string>) => ExpandedProbes;
+//#endregion
+export { AntdProbeDef, AntdProbeName, ExpandedProbes, antdProbeNames, antdProbeRegistry, expandComponentsToProbes, nonProbeAntdExports };
+//# sourceMappingURL=registry.d.mts.map