@jinmi/ui 6.0.1 → 6.1.0

package/es/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
 // ==================================================================================================
 // JSON Schema Draft 04
 // ==================================================================================================
@@ -196,6 +195,5 @@ interface JSONSchema4 {
   [k: string]: any;
   format?: string | undefined;
 }
-//#endregion
 export { JSONSchema4, JSONSchema4Array, JSONSchema4Object, JSONSchema4Type, JSONSchema4TypeName, JSONSchema4Version };
 //# sourceMappingURL=index.d.mts.map

package/es/node_modules/.pnpm/@types_mdx@2.0.14/node_modules/@types/mdx/types.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/@types+mdx@2.0.14/node_modules/@types/mdx/types.d.ts
 // Internal helper types
 /**
  * This is the global JSX.ElementType if it’s defined, otherwise never.
@@ -61,6 +60,5 @@ type MDXComponents = NestedMDXComponents & { [Key in StringComponent]?: Componen
    */
   wrapper?: Component<any>;
 };
-//#endregion
 export { Element, MDXComponents };
 //# sourceMappingURL=types.d.mts.map

package/es/node_modules/.pnpm/@types_unist@3.0.3/node_modules/@types/unist/index.d.mts

@@ -1,4 +1,3 @@
-//#region node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts
 // ## Interfaces
 /**
  * Info associated with nodes by the ecosystem.
@@ -79,6 +78,5 @@ interface Node {
    */
   position?: Position | undefined;
 }
-//#endregion
 export { Data, Node, Point, Position };
 //# sourceMappingURL=index.d.mts.map

package/es/node_modules/.pnpm/{eslint@9.39.5_jiti@2.6.1_supports-color@10.2.2 → eslint@9.39.5_jiti@2.7.0_supports-color@10.2.2}/node_modules/eslint/lib/types/index.d.mts

@@ -1,6 +1,5 @@
 import { ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BinaryExpression, BlockStatement, BreakStatement, CatchClause, ChainExpression, ClassBody, ClassDeclaration, ClassExpression, Comment, ConditionalExpression, ContinueStatement, DebuggerStatement, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, LabeledStatement, Literal, LogicalExpression, MemberExpression, MetaProperty, MethodDefinition, NewExpression, Node as Node$1, ObjectExpression, ObjectPattern, Position, PrivateIdentifier, Program, Property, PropertyDefinition, RestElement, ReturnStatement, SequenceExpression, SimpleCallExpression, SourceLocation as SourceLocation$1, SpreadElement, StaticBlock, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression } from "../../../../../@types_estree@1.0.9/node_modules/@types/estree/index.mjs";
 import { BaseConfig, ConfigObject, ConfigOverride, DeprecatedInfo, EcmaVersion as EcmaVersion$1, EnvironmentConfig, GlobalAccess, GlobalsConfig, HasRules, JavaScriptParserOptionsConfig, JavaScriptSourceType, LanguageOptions, LegacyConfigObject, LintMessage as LintMessage$1, LintSuggestion, LinterOptionsConfig, ObjectMetaProperties, Plugin as Plugin$1, Processor, ProcessorFile as ProcessorFile$1, RuleConfig, RuleContext as RuleContext$1, RuleDefinition, RuleFixer, RuleTextEdit, RuleTextEditor, RuleVisitor, RulesConfig, RulesMeta, Severity, SeverityLevel, SeverityName, SourceRange, SuggestedEdit, SuggestedEditBase, SuggestionMessage, TextSourceCode, TraversalStep, ViolationLocation, ViolationMessage, ViolationReport, ViolationReportBase } from "../../../../../@eslint_core@0.17.0/node_modules/@eslint/core/dist/esm/types.mjs";
-//#region node_modules/.pnpm/eslint@9.39.5_jiti@2.6.1_supports-color@10.2.2/node_modules/eslint/lib/types/index.d.ts
 //------------------------------------------------------------------------------
 // Exports
 //------------------------------------------------------------------------------
@@ -957,6 +956,5 @@ declare namespace ESLint {
   // Docs reference the types by those name
   type EditInfo = Rule.Fix;
 }
-//#endregion
 export { AST, ESLint, JSSyntaxElement, Linter, Rule, Scope, SourceCode };
 //# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1,289 @@
+import { SKIP as SKIP$1, visitParents } from "unist-util-visit-parents";
+// node_modules/.pnpm/unist-util-visit@5.2.0/node_modules/unist-util-visit/lib/index.js
+/**
+* @import {Node as UnistNode, Parent as UnistParent} from 'unist'
+* @import {
+*   InclusiveDescendant,
+*   Matches,
+*   Visitors as ParentsVisitors,
+*   VisitorResult,
+*   VisitorResultExit
+* } 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 {(
+*   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.
+*/
+/**
+* @callback Visitor
+*   Handle a node (matching `test`, if given) before its children.
+*
+*   Like `Visitor` in `unist-util-visit-parents`,
+*   but with `index` and `parent` instead of `parents`.
+* @param {Visited} node
+*   Found node.
+* @param {Visited extends UnistNode ? number | undefined : never} index
+*   Index of `node` in `parent`,
+*   or `undefined` for the tree itself.
+* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+*   Parent of `node`,
+*   or `undefined` for the tree itself.
+* @returns {VisitorResult}
+*   What to do next.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @callback VisitorExit
+*   Handle a node (matching `test`, if given) after its children.
+*
+*   Like `VisitorExit` in `unist-util-visit-parents`,
+*   but with `index` and `parent` instead of `parents`.
+* @param {Visited} node
+*   Found node.
+* @param {Visited extends UnistNode ? number | undefined : never} index
+*   Index of `node` in `parent`,
+*   or `undefined` for the tree itself.
+* @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+*   Parent of `node`,
+*   or `undefined` for the tree itself.
+* @returns {VisitorResultExit}
+*   What to do next.
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+*/
+/**
+* @template {UnistNode} [Visited=UnistNode]
+*   Visited node type.
+* @template {UnistParent} [Ancestor=UnistParent]
+*   Ancestor type.
+* @typedef Visitors
+*   Handle nodes when entering and exiting them.
+*
+*   Like `Visitors` in `unist-util-visit-parents`.
+* @property {Visitor<Visited, Ancestor> | null | undefined} [enter]
+*   Handle a node before its children (optional).
+* @property {VisitorExit<Visited, Ancestor>} exit
+*   Handle a node after its children.
+*/
+/**
+* @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.
+*/
+/**
+* @typedef {(
+*   Visitors<
+*     Matches<InclusiveDescendant<Tree>, Check>,
+*     Parent<
+*       Extract<InclusiveDescendant<Tree>, UnistParent>,
+*       Matches<InclusiveDescendant<Tree>, Check>
+*     >
+*   >
+* )} BuildVisitors
+*   Build typed `Visitors` 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**).
+* An `exit` visitor is called in *postorder* (**LRN**)
+* or if `reverse` is given, in *reverse postorder* (**RLN**).
+*
+* You can choose which nodes are visited by passing a `test`.
+* For complex tests, you should test yourself in a 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.
+* Changes inside a node made when entering it are walked,
+* changes made when exiting it are not.
+* See `Visitor` and `VisitorExit` for more info.
+*
+* @overload
+* @param {Tree} tree
+*   Tree to traverse.
+* @param {Check} check
+*   `unist-util-is`-compatible test.
+* @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors
+*   Handle each node when entering it,
+*   or `{enter, exit}` to also handle it when exiting it.
+* @param {boolean | null | undefined} [reverse]
+*   Walk children from last to first;
+*   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+*   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+* @returns {undefined}
+*   Nothing.
+*
+* @overload
+* @param {Tree} tree
+*   Tree to traverse.
+* @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors
+*   Handle each node when entering it,
+*   or `{enter, exit}` to also handle it when exiting it.
+* @param {boolean | null | undefined} [reverse]
+*   Walk children from last to first;
+*   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+*   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+* @returns {undefined}
+*   Nothing.
+*
+* @param {UnistNode} tree
+*   Tree to traverse.
+* @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+*   `unist-util-is`-compatible test, `enter`, or `visitors`.
+* @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+*   `enter`, `visitors`, or `reverse` after a test.
+* @param {boolean | null | undefined} [maybeReverse]
+*   Walk children from last to first;
+*   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+*   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+* @returns {undefined}
+*   Nothing.
+*
+* @template {UnistNode} Tree
+*   Node type.
+* @template {Test} Check
+*   `unist-util-is`-compatible test.
+*/
+function visit(tree, testOrEnterOrVisitors, enterOrVisitorsOrReverse, maybeReverse) {
+	/** @type {Test} */
+	let check;
+	/** @type {Visitor | Visitors} */
+	let visitors;
+	/** @type {boolean | null | undefined} */
+	let reverse;
+	if (typeof enterOrVisitorsOrReverse === "function" || enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === "object") {
+		check = testOrEnterOrVisitors;
+		visitors = enterOrVisitorsOrReverse;
+		reverse = maybeReverse;
+	} else {
+		visitors = testOrEnterOrVisitors;
+		reverse = enterOrVisitorsOrReverse;
+	}
+	if (typeof visitors === "function") visitParents(tree, check, wrap(visitors), reverse);
+	else visitParents(tree, check, wrapVisitors(visitors), reverse);
+}
+/**
+* Turn `visit` visitors into `visitParents` visitors.
+*
+* @param {Visitors} visitors
+*   Visitors for `visit`.
+* @returns {ParentsVisitors}
+*   Visitors for `visitParents`.
+*/
+function wrapVisitors(visitors) {
+	if (!visitors || typeof visitors !== "object") return visitors;
+	return {
+		enter: typeof visitors.enter === "function" ? wrap(visitors.enter) : visitors.enter,
+		exit: typeof visitors.exit === "function" ? wrap(visitors.exit) : visitors.exit
+	};
+}
+/**
+* Turn a `visit` visitor into a `visitParents` one.
+*
+* @template {VisitorResult} Result
+*   Result type.
+* @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor
+*   Visitor for `visit`.
+* @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}
+*   Visitor for `visitParents`.
+*/
+function wrap(visitor) {
+	return overload;
+	/**
+	* Call `visitor` with `index` and `parent` instead of `parents`.
+	*
+	* @param {UnistNode} node
+	*   Visited node.
+	* @param {Array<UnistParent>} parents
+	*   Ancestors of `node`.
+	* @param {number | undefined} index
+	*   Index of `node` in its parent.
+	* @returns {Result}
+	*   What to do next.
+	*/
+	function overload(node, parents, index) {
+		return visitor(node, index, parents[parents.length - 1]);
+	}
+}
+export { SKIP$1 as SKIP, visit };
+
+//# sourceMappingURL=index.mjs.map

package/es/node_modules/.pnpm/unist-util-visit@5.2.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.2.0/node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n * @import {\n *   InclusiveDescendant,\n *   Matches,\n *   Visitors as ParentsVisitors,\n *   VisitorResult,\n *   VisitorResultExit\n * } 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/**\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 * @callback Visitor\n *   Handle a node (matching `test`, if given) before its children.\n *\n *   Like `Visitor` in `unist-util-visit-parents`,\n *   but with `index` and `parent` instead of `parents`.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`,\n *   or `undefined` for the tree itself.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`,\n *   or `undefined` for the tree itself.\n * @returns {VisitorResult}\n *   What to do next.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @callback VisitorExit\n *   Handle a node (matching `test`, if given) after its children.\n *\n *   Like `VisitorExit` in `unist-util-visit-parents`,\n *   but with `index` and `parent` instead of `parents`.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`,\n *   or `undefined` for the tree itself.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`,\n *   or `undefined` for the tree itself.\n * @returns {VisitorResultExit}\n *   What to do next.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n * @typedef Visitors\n *   Handle nodes when entering and exiting them.\n *\n *   Like `Visitors` in `unist-util-visit-parents`.\n * @property {Visitor<Visited, Ancestor> | null | undefined} [enter]\n *   Handle a node before its children (optional).\n * @property {VisitorExit<Visited, Ancestor>} exit\n *   Handle a node after its children.\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\n/**\n * @typedef {(\n *   Visitors<\n *     Matches<InclusiveDescendant<Tree>, Check>,\n *     Parent<\n *       Extract<InclusiveDescendant<Tree>, UnistParent>,\n *       Matches<InclusiveDescendant<Tree>, Check>\n *     >\n *   >\n * )} BuildVisitors\n *   Build typed `Visitors` 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,\n * in *reverse preorder* (**NRL**).\n * An `exit` visitor is called in *postorder* (**LRN**)\n * or if `reverse` is given, in *reverse postorder* (**RLN**).\n *\n * You can choose which nodes are visited by passing a `test`.\n * For complex tests, you should test yourself in a 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 * Changes inside a node made when entering it are walked,\n * changes made when exiting it are not.\n * See `Visitor` and `VisitorExit` for more info.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {Check} check\n *   `unist-util-is`-compatible test.\n * @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors\n *   Handle each node when entering it,\n *   or `{enter, exit}` to also handle it when exiting it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @overload\n * @param {Tree} tree\n *   Tree to traverse.\n * @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors\n *   Handle each node when entering it,\n *   or `{enter, exit}` to also handle it when exiting it.\n * @param {boolean | null | undefined} [reverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\n * @returns {undefined}\n *   Nothing.\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Visitors | Test} testOrEnterOrVisitors\n *   `unist-util-is`-compatible test, `enter`, or `visitors`.\n * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]\n *   `enter`, `visitors`, or `reverse` after a test.\n * @param {boolean | null | undefined} [maybeReverse]\n *   Walk children from last to first;\n *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);\n *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).\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(\n  tree,\n  testOrEnterOrVisitors,\n  enterOrVisitorsOrReverse,\n  maybeReverse\n) {\n  /** @type {Test} */\n  let check\n  /** @type {Visitor | Visitors} */\n  let visitors\n  /** @type {boolean | null | undefined} */\n  let reverse\n\n  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.\n  if (\n    typeof enterOrVisitorsOrReverse === 'function' ||\n    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')\n  ) {\n    check = /** @type {Test} */ (testOrEnterOrVisitors)\n    visitors = enterOrVisitorsOrReverse\n    reverse = maybeReverse\n  }\n  // Assume no test.\n  else {\n    visitors = /** @type {Visitor | Visitors} */ (testOrEnterOrVisitors)\n    reverse = enterOrVisitorsOrReverse\n  }\n\n  if (typeof visitors === 'function') {\n    visitParents(tree, check, wrap(visitors), reverse)\n  } else {\n    visitParents(tree, check, wrapVisitors(visitors), reverse)\n  }\n}\n\n/**\n * Turn `visit` visitors into `visitParents` visitors.\n *\n * @param {Visitors} visitors\n *   Visitors for `visit`.\n * @returns {ParentsVisitors}\n *   Visitors for `visitParents`.\n */\nfunction wrapVisitors(visitors) {\n  // Pass anything else straight to `visitParents` to get its errors.\n  if (!visitors || typeof visitors !== 'object') return visitors\n\n  return {\n    enter:\n      typeof visitors.enter === 'function'\n        ? wrap(visitors.enter)\n        : visitors.enter,\n    exit:\n      typeof visitors.exit === 'function' ? wrap(visitors.exit) : visitors.exit\n  }\n}\n\n/**\n * Turn a `visit` visitor into a `visitParents` one.\n *\n * @template {VisitorResult} Result\n *   Result type.\n * @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor\n *   Visitor for `visit`.\n * @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}\n *   Visitor for `visitParents`.\n */\nfunction wrap(visitor) {\n  return overload\n\n  /**\n   * Call `visitor` with `index` and `parent` instead of `parents`.\n   *\n   * @param {UnistNode} node\n   *   Visited node.\n   * @param {Array<UnistParent>} parents\n   *   Ancestors of `node`.\n   * @param {number | undefined} index\n   *   Index of `node` in its parent.\n   * @returns {Result}\n   *   What to do next.\n   */\n  function overload(node, parents, index) {\n    return visitor(node, index, parents[parents.length - 1])\n  }\n}\n"],"ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8OA,SAAgB,MACd,MACA,uBACA,0BACA,cACA;;CAEA,IAAI;;CAEJ,IAAI;;CAEJ,IAAI;CAGJ,IACE,OAAO,6BAA6B,cACnC,4BAA4B,OAAO,6BAA6B,UACjE;EACA,QAA6B;EAC7B,WAAW;EACX,UAAU;CACZ,OAEK;EACH,WAA8C;EAC9C,UAAU;CACZ;CAEA,IAAI,OAAO,aAAa,YACtB,aAAa,MAAM,OAAO,KAAK,QAAQ,GAAG,OAAO;MAEjD,aAAa,MAAM,OAAO,aAAa,QAAQ,GAAG,OAAO;AAE7D;;;;;;;;;AAUA,SAAS,aAAa,UAAU;CAE9B,IAAI,CAAC,YAAY,OAAO,aAAa,UAAU,OAAO;CAEtD,OAAO;EACL,OACE,OAAO,SAAS,UAAU,aACtB,KAAK,SAAS,KAAK,IACnB,SAAS;EACf,MACE,OAAO,SAAS,SAAS,aAAa,KAAK,SAAS,IAAI,IAAI,SAAS;CACzE;AACF;;;;;;;;;;;AAYA,SAAS,KAAK,SAAS;CACrB,OAAO;;;;;;;;;;;;;CAcP,SAAS,SAAS,MAAM,SAAS,OAAO;EACtC,OAAO,QAAQ,MAAM,OAAO,QAAQ,QAAQ,SAAS,EAAE;CACzD;AACF"}

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

@@ -1,6 +1,4 @@
 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

@@ -1,4 +1,4 @@
-//#region src/static-css/baseline.ts
+// src/static-css/baseline.ts
 const lobeUiAntdBaseline = [
 	"alert",
 	"anchor",
@@ -25,7 +25,6 @@ const lobeUiAntdBaseline = [
 	"tag-preset",
 	"tag-status"
 ];
-//#endregion
 export { lobeUiAntdBaseline };
 
 //# sourceMappingURL=baseline.mjs.map

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

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

@@ -2,7 +2,6 @@ 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][];
@@ -26,6 +25,5 @@ interface AntdStaticCssPayload {
 }
 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

@@ -9,7 +9,7 @@ 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
+// src/static-css/buildAntdStaticCss.ts
 const createProbeAntdTheme = () => {
 	const config = createLobeAntdTheme({ appearance: "light" });
 	return {
@@ -65,7 +65,6 @@ const buildAntdStaticCss = (options = {}) => {
 		unmatchedComponents
 	};
 };
-//#endregion
 export { buildAntdStaticCss, createProbeAntdTheme };
 
 //# sourceMappingURL=buildAntdStaticCss.mjs.map

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

@@ -1,6 +1,5 @@
 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;
@@ -13,6 +12,5 @@ interface EmitStaticCssResult {
   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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { mkdir, writeFile } from "node:fs/promises";
-//#region src/static-css/emit/index.ts
+// 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;
@@ -36,7 +36,6 @@ const emitStaticCssAssets = async (options) => {
 	result.files.push(manifestPath);
 	return result;
 };
-//#endregion
 export { emitStaticCssAssets };
 
 //# sourceMappingURL=index.mjs.map

package/es/static-css/hash.mjs

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
-//#region src/static-css/hash.ts
+// 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/registry.d.mts

@@ -1,5 +1,4 @@
 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;
@@ -15,6 +14,5 @@ interface ExpandedProbes {
   unmatched: string[];
 }
 declare const expandComponentsToProbes: (components: Iterable<string>) => ExpandedProbes;
-//#endregion
 export { AntdProbeDef, AntdProbeName, ExpandedProbes, antdProbeNames, antdProbeRegistry, expandComponentsToProbes, nonProbeAntdExports };
 //# sourceMappingURL=registry.d.mts.map

package/es/static-css/registry.mjs

@@ -292,7 +292,6 @@ const expandComponentsToProbes = (components) => {
 		unmatched: unmatched.sort()
 	};
 };
-//#endregion
 export { antdProbeNames, antdProbeRegistry, expandComponentsToProbes, nonProbeAntdExports };
 
 //# sourceMappingURL=registry.mjs.map

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

@@ -1,4 +1,3 @@
-//#region src/static-css/runtime/index.d.ts
 interface InlineAntdStyleResult {
   css: string;
   /** css wrapped in a prepend-ordered style tag, '' when empty */
@@ -9,6 +8,5 @@ interface InlineAntdStyleResult {
 declare const buildInlineAntdStyle: (runtimeCache: unknown, payload: {
   styleKeys: Iterable<string>;
 }) => InlineAntdStyleResult;
-//#endregion
 export { InlineAntdStyleResult, buildInlineAntdStyle };
 //# sourceMappingURL=index.d.mts.map

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

@@ -1,6 +1,6 @@
 import { styleKeysOf } from "../shared.mjs";
 import { extractStyle } from "@ant-design/cssinjs";
-//#region src/static-css/runtime/index.ts
+// src/static-css/runtime/index.ts
 const buildInlineAntdStyle = (runtimeCache, payload) => {
 	const staticKeys = payload.styleKeys instanceof Set ? payload.styleKeys : new Set(payload.styleKeys);
 	const cssinjsCache = runtimeCache;
@@ -28,7 +28,6 @@ const buildInlineAntdStyle = (runtimeCache, payload) => {
 		uncovered: uncoveredKeys.map((key) => key.split("%")[2] ?? key)
 	};
 };
-//#endregion
 export { buildInlineAntdStyle };
 
 //# sourceMappingURL=index.mjs.map

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

@@ -1,4 +1,3 @@
-//#region src/static-css/scan.d.ts
 interface ScanAntdUsageOptions {
   cwd?: string;
   exclude?: RegExp[];
@@ -14,6 +13,5 @@ interface AntdUsageScanResult {
   wildcard: boolean;
 }
 declare const scanAntdUsage: (options?: ScanAntdUsageOptions) => AntdUsageScanResult;
-//#endregion
 export { AntdUsageScanResult, ScanAntdUsageOptions, scanAntdUsage };
 //# sourceMappingURL=scan.d.mts.map

package/es/static-css/scan.mjs

@@ -1,6 +1,6 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
-//#region src/static-css/scan.ts
+// src/static-css/scan.ts
 const DEFAULT_EXTENSIONS = [
 	"ts",
 	"tsx",
@@ -82,7 +82,6 @@ const scanAntdUsage = (options = {}) => {
 		wildcard
 	};
 };
-//#endregion
 export { scanAntdUsage };
 
 //# sourceMappingURL=scan.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"scan.mjs","names":[],"sources":["../../src/static-css/scan.ts"],"sourcesContent":["import { readdirSync, readFileSync, statSync } from 'node:fs';\r\nimport path from 'node:path';\r\n\r\nexport interface ScanAntdUsageOptions {\r\n  cwd?: string;\r\n  exclude?: RegExp[];\r\n  extensions?: string[];\r\n  roots?: string[];\r\n}\r\n\r\nexport interface AntdUsageScanResult {\r\n  /** PascalCase antd export names found in value imports */\r\n  components: string[];\r\n  importsLobeUi: boolean;\r\n  scannedFiles: number;\r\n  /** a namespace/default antd import was found — usage is not statically enumerable */\r\n  wildcard: boolean;\r\n}\r\n\r\nconst DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'mts', 'cjs', 'cts'];\r\nconst DEFAULT_EXCLUDE = [/node_modules/, /\\.test\\./, /\\.spec\\./, /\\.d\\.[cm]?ts$/, /__tests__/];\r\n\r\n// clause alternatives ({named} / Default / Default, {named} / * as ns) deliberately\r\n// exclude statement-crossing text so one match never spans two imports\r\nconst NAMED_IMPORT_RE =\r\n  /import\\s+(type\\s+)?((?:[\\w$]+\\s*,\\s*)?\\{[^}]*\\}|[\\w$]+|\\*\\s+as\\s+[\\w$]+)\\s+from\\s+['\"]antd['\"]/g;\r\n// type-only deep imports are included too — over-approximation is harmless here\r\nconst DEEP_IMPORT_RE = /from\\s+['\"]antd\\/(?:es|lib)\\/([\\w-]+)/g;\r\n// `@lobehub/ui` stays matched: consumers alias it to @jinmi/ui for third-party peers.\r\nconst LOBE_UI_RE = /from\\s+['\"]@(?:jinmi|lobehub)\\/ui(?:['\"]|\\/)/;\r\n\r\nconst kebabToPascal = (name: string) =>\r\n  name\r\n    .split('-')\r\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\r\n    .join('');\r\n\r\nconst parseImportClause = (clause: string, components: Set<string>): boolean => {\r\n  const braceStart = clause.indexOf('{');\r\n\r\n  const bare = (braceStart === -1 ? clause : clause.slice(0, braceStart)).trim();\r\n  const wildcard = bare.length > 0;\r\n\r\n  if (braceStart === -1) return wildcard;\r\n\r\n  const inner = clause.slice(braceStart + 1, clause.lastIndexOf('}'));\r\n  for (const rawSpecifier of inner.split(',')) {\r\n    const specifier = rawSpecifier.trim();\r\n    if (!specifier || specifier.startsWith('type ')) continue;\r\n    const name = specifier.split(/\\s+as\\s+/)[0]!.trim();\r\n    if (/^[A-Za-z_$][\\w$]*$/.test(name)) components.add(name);\r\n  }\r\n\r\n  return wildcard;\r\n};\r\n\r\nconst listFiles = (root: string, extensions: Set<string>, exclude: RegExp[]): string[] => {\r\n  let entries: string[];\r\n  try {\r\n    entries = readdirSync(root, { recursive: true }) as string[];\r\n  } catch {\r\n    return [];\r\n  }\r\n\r\n  return entries\r\n    .map((entry) => path.join(root, entry))\r\n    .filter((path) => {\r\n      // Exclude patterns are written with `/`; normalize Windows separators first.\r\n      const posixPath = path.replaceAll('\\\\', '/');\r\n      if (exclude.some((pattern) => pattern.test(posixPath))) return false;\r\n      const extension = path.split('.').pop();\r\n      if (!extension || !extensions.has(extension)) return false;\r\n      try {\r\n        return statSync(path).isFile();\r\n      } catch {\r\n        return false;\r\n      }\r\n    });\r\n};\r\n\r\nexport const scanAntdUsage = (options: ScanAntdUsageOptions = {}): AntdUsageScanResult => {\r\n  const {\r\n    cwd = process.cwd(),\r\n    roots = ['src'],\r\n    extensions = DEFAULT_EXTENSIONS,\r\n    exclude = DEFAULT_EXCLUDE,\r\n  } = options;\r\n\r\n  const components = new Set<string>();\r\n  let importsLobeUi = false;\r\n  let wildcard = false;\r\n  let scannedFiles = 0;\r\n\r\n  for (const root of roots) {\r\n    for (const file of listFiles(path.resolve(cwd, root), new Set(extensions), exclude)) {\r\n      let source: string;\r\n      try {\r\n        source = readFileSync(file, 'utf8');\r\n      } catch {\r\n        continue;\r\n      }\r\n      scannedFiles += 1;\r\n\r\n      if (!importsLobeUi && LOBE_UI_RE.test(source)) importsLobeUi = true;\r\n\r\n      for (const match of source.matchAll(NAMED_IMPORT_RE)) {\r\n        if (match[1]) continue;\r\n        if (parseImportClause(match[2]!, components)) wildcard = true;\r\n      }\r\n\r\n      for (const match of source.matchAll(DEEP_IMPORT_RE)) {\r\n        components.add(kebabToPascal(match[1]!));\r\n      }\r\n    }\r\n  }\r\n\r\n  return { components: [...components].sort(), importsLobeUi, scannedFiles, wildcard };\r\n};\r\n"],"mappings":";;;AAmBA,MAAM,qBAAqB;CAAC;CAAM;CAAO;CAAM;CAAO;CAAO;CAAO;CAAO;AAAK;AAChF,MAAM,kBAAkB;CAAC;CAAgB;CAAY;CAAY;CAAiB;AAAW;AAI7F,MAAM,kBACJ;AAEF,MAAM,iBAAiB;AAEvB,MAAM,aAAa;AAEnB,MAAM,iBAAiB,SACrB,KACG,MAAM,GAAG,CAAC,CACV,KAAK,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAC3D,KAAK,EAAE;AAEZ,MAAM,qBAAqB,QAAgB,eAAqC;CAC9E,MAAM,aAAa,OAAO,QAAQ,GAAG;CAGrC,MAAM,YADQ,eAAe,KAAK,SAAS,OAAO,MAAM,GAAG,UAAU,EAAA,CAAG,KACpD,CAAC,CAAC,SAAS;CAE/B,IAAI,eAAe,IAAI,OAAO;CAE9B,MAAM,QAAQ,OAAO,MAAM,aAAa,GAAG,OAAO,YAAY,GAAG,CAAC;CAClE,KAAK,MAAM,gBAAgB,MAAM,MAAM,GAAG,GAAG;EAC3C,MAAM,YAAY,aAAa,KAAK;EACpC,IAAI,CAAC,aAAa,UAAU,WAAW,OAAO,GAAG;EACjD,MAAM,OAAO,UAAU,MAAM,UAAU,CAAC,CAAC,EAAE,CAAE,KAAK;EAClD,IAAI,qBAAqB,KAAK,IAAI,GAAG,WAAW,IAAI,IAAI;CAC1D;CAEA,OAAO;AACT;AAEA,MAAM,aAAa,MAAc,YAAyB,YAAgC;CACxF,IAAI;CACJ,IAAI;EACF,UAAU,YAAY,MAAM,EAAE,WAAW,KAAK,CAAC;CACjD,QAAQ;EACN,OAAO,CAAC;CACV;CAEA,OAAO,QACJ,KAAK,UAAU,KAAK,KAAK,MAAM,KAAK,CAAC,CAAC,CACtC,QAAQ,SAAS;EAEhB,MAAM,YAAY,KAAK,WAAW,MAAM,GAAG;EAC3C,IAAI,QAAQ,MAAM,YAAY,QAAQ,KAAK,SAAS,CAAC,GAAG,OAAO;EAC/D,MAAM,YAAY,KAAK,MAAM,GAAG,CAAC,CAAC,IAAI;EACtC,IAAI,CAAC,aAAa,CAAC,WAAW,IAAI,SAAS,GAAG,OAAO;EACrD,IAAI;GACF,OAAO,SAAS,IAAI,CAAC,CAAC,OAAO;EAC/B,QAAQ;GACN,OAAO;EACT;CACF,CAAC;AACL;AAEA,MAAa,iBAAiB,UAAgC,CAAC,MAA2B;CACxF,MAAM,EACJ,MAAM,QAAQ,IAAI,GAClB,QAAQ,CAAC,KAAK,GACd,aAAa,oBACb,UAAU,oBACR;CAEJ,MAAM,6BAAa,IAAI,IAAY;CACnC,IAAI,gBAAgB;CACpB,IAAI,WAAW;CACf,IAAI,eAAe;CAEnB,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,QAAQ,UAAU,KAAK,QAAQ,KAAK,IAAI,GAAG,IAAI,IAAI,UAAU,GAAG,OAAO,GAAG;EACnF,IAAI;EACJ,IAAI;GACF,SAAS,aAAa,MAAM,MAAM;EACpC,QAAQ;GACN;EACF;EACA,gBAAgB;EAEhB,IAAI,CAAC,iBAAiB,WAAW,KAAK,MAAM,GAAG,gBAAgB;EAE/D,KAAK,MAAM,SAAS,OAAO,SAAS,eAAe,GAAG;GACpD,IAAI,MAAM,IAAI;GACd,IAAI,kBAAkB,MAAM,IAAK,UAAU,GAAG,WAAW;EAC3D;EAEA,KAAK,MAAM,SAAS,OAAO,SAAS,cAAc,GAChD,WAAW,IAAI,cAAc,MAAM,EAAG,CAAC;CAE3C;CAGF,OAAO;EAAE,YAAY,CAAC,GAAG,UAAU,CAAC,CAAC,KAAK;EAAG;EAAe;EAAc;CAAS;AACrF"}
+{"version":3,"file":"scan.mjs","names":[],"sources":["../../src/static-css/scan.ts"],"sourcesContent":["import { readdirSync, readFileSync, statSync } from 'node:fs';\nimport path from 'node:path';\n\nexport interface ScanAntdUsageOptions {\n  cwd?: string;\n  exclude?: RegExp[];\n  extensions?: string[];\n  roots?: string[];\n}\n\nexport interface AntdUsageScanResult {\n  /** PascalCase antd export names found in value imports */\n  components: string[];\n  importsLobeUi: boolean;\n  scannedFiles: number;\n  /** a namespace/default antd import was found — usage is not statically enumerable */\n  wildcard: boolean;\n}\n\nconst DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'mts', 'cjs', 'cts'];\nconst DEFAULT_EXCLUDE = [/node_modules/, /\\.test\\./, /\\.spec\\./, /\\.d\\.[cm]?ts$/, /__tests__/];\n\n// clause alternatives ({named} / Default / Default, {named} / * as ns) deliberately\n// exclude statement-crossing text so one match never spans two imports\nconst NAMED_IMPORT_RE =\n  /import\\s+(type\\s+)?((?:[\\w$]+\\s*,\\s*)?\\{[^}]*\\}|[\\w$]+|\\*\\s+as\\s+[\\w$]+)\\s+from\\s+['\"]antd['\"]/g;\n// type-only deep imports are included too — over-approximation is harmless here\nconst DEEP_IMPORT_RE = /from\\s+['\"]antd\\/(?:es|lib)\\/([\\w-]+)/g;\n// `@lobehub/ui` stays matched: consumers alias it to @jinmi/ui for third-party peers.\nconst LOBE_UI_RE = /from\\s+['\"]@(?:jinmi|lobehub)\\/ui(?:['\"]|\\/)/;\n\nconst kebabToPascal = (name: string) =>\n  name\n    .split('-')\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\n    .join('');\n\nconst parseImportClause = (clause: string, components: Set<string>): boolean => {\n  const braceStart = clause.indexOf('{');\n\n  const bare = (braceStart === -1 ? clause : clause.slice(0, braceStart)).trim();\n  const wildcard = bare.length > 0;\n\n  if (braceStart === -1) return wildcard;\n\n  const inner = clause.slice(braceStart + 1, clause.lastIndexOf('}'));\n  for (const rawSpecifier of inner.split(',')) {\n    const specifier = rawSpecifier.trim();\n    if (!specifier || specifier.startsWith('type ')) continue;\n    const name = specifier.split(/\\s+as\\s+/)[0]!.trim();\n    if (/^[A-Za-z_$][\\w$]*$/.test(name)) components.add(name);\n  }\n\n  return wildcard;\n};\n\nconst listFiles = (root: string, extensions: Set<string>, exclude: RegExp[]): string[] => {\n  let entries: string[];\n  try {\n    entries = readdirSync(root, { recursive: true }) as string[];\n  } catch {\n    return [];\n  }\n\n  return entries\n    .map((entry) => path.join(root, entry))\n    .filter((path) => {\n      // Exclude patterns are written with `/`; normalize Windows separators first.\n      const posixPath = path.replaceAll('\\\\', '/');\n      if (exclude.some((pattern) => pattern.test(posixPath))) return false;\n      const extension = path.split('.').pop();\n      if (!extension || !extensions.has(extension)) return false;\n      try {\n        return statSync(path).isFile();\n      } catch {\n        return false;\n      }\n    });\n};\n\nexport const scanAntdUsage = (options: ScanAntdUsageOptions = {}): AntdUsageScanResult => {\n  const {\n    cwd = process.cwd(),\n    roots = ['src'],\n    extensions = DEFAULT_EXTENSIONS,\n    exclude = DEFAULT_EXCLUDE,\n  } = options;\n\n  const components = new Set<string>();\n  let importsLobeUi = false;\n  let wildcard = false;\n  let scannedFiles = 0;\n\n  for (const root of roots) {\n    for (const file of listFiles(path.resolve(cwd, root), new Set(extensions), exclude)) {\n      let source: string;\n      try {\n        source = readFileSync(file, 'utf8');\n      } catch {\n        continue;\n      }\n      scannedFiles += 1;\n\n      if (!importsLobeUi && LOBE_UI_RE.test(source)) importsLobeUi = true;\n\n      for (const match of source.matchAll(NAMED_IMPORT_RE)) {\n        if (match[1]) continue;\n        if (parseImportClause(match[2]!, components)) wildcard = true;\n      }\n\n      for (const match of source.matchAll(DEEP_IMPORT_RE)) {\n        components.add(kebabToPascal(match[1]!));\n      }\n    }\n  }\n\n  return { components: [...components].sort(), importsLobeUi, scannedFiles, wildcard };\n};\n"],"mappings":";;;AAmBA,MAAM,qBAAqB;CAAC;CAAM;CAAO;CAAM;CAAO;CAAO;CAAO;CAAO;AAAK;AAChF,MAAM,kBAAkB;CAAC;CAAgB;CAAY;CAAY;CAAiB;AAAW;AAI7F,MAAM,kBACJ;AAEF,MAAM,iBAAiB;AAEvB,MAAM,aAAa;AAEnB,MAAM,iBAAiB,SACrB,KACG,MAAM,GAAG,CAAC,CACV,KAAK,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAC3D,KAAK,EAAE;AAEZ,MAAM,qBAAqB,QAAgB,eAAqC;CAC9E,MAAM,aAAa,OAAO,QAAQ,GAAG;CAGrC,MAAM,YADQ,eAAe,KAAK,SAAS,OAAO,MAAM,GAAG,UAAU,EAAA,CAAG,KACpD,CAAC,CAAC,SAAS;CAE/B,IAAI,eAAe,IAAI,OAAO;CAE9B,MAAM,QAAQ,OAAO,MAAM,aAAa,GAAG,OAAO,YAAY,GAAG,CAAC;CAClE,KAAK,MAAM,gBAAgB,MAAM,MAAM,GAAG,GAAG;EAC3C,MAAM,YAAY,aAAa,KAAK;EACpC,IAAI,CAAC,aAAa,UAAU,WAAW,OAAO,GAAG;EACjD,MAAM,OAAO,UAAU,MAAM,UAAU,CAAC,CAAC,EAAE,CAAE,KAAK;EAClD,IAAI,qBAAqB,KAAK,IAAI,GAAG,WAAW,IAAI,IAAI;CAC1D;CAEA,OAAO;AACT;AAEA,MAAM,aAAa,MAAc,YAAyB,YAAgC;CACxF,IAAI;CACJ,IAAI;EACF,UAAU,YAAY,MAAM,EAAE,WAAW,KAAK,CAAC;CACjD,QAAQ;EACN,OAAO,CAAC;CACV;CAEA,OAAO,QACJ,KAAK,UAAU,KAAK,KAAK,MAAM,KAAK,CAAC,CAAC,CACtC,QAAQ,SAAS;EAEhB,MAAM,YAAY,KAAK,WAAW,MAAM,GAAG;EAC3C,IAAI,QAAQ,MAAM,YAAY,QAAQ,KAAK,SAAS,CAAC,GAAG,OAAO;EAC/D,MAAM,YAAY,KAAK,MAAM,GAAG,CAAC,CAAC,IAAI;EACtC,IAAI,CAAC,aAAa,CAAC,WAAW,IAAI,SAAS,GAAG,OAAO;EACrD,IAAI;GACF,OAAO,SAAS,IAAI,CAAC,CAAC,OAAO;EAC/B,QAAQ;GACN,OAAO;EACT;CACF,CAAC;AACL;AAEA,MAAa,iBAAiB,UAAgC,CAAC,MAA2B;CACxF,MAAM,EACJ,MAAM,QAAQ,IAAI,GAClB,QAAQ,CAAC,KAAK,GACd,aAAa,oBACb,UAAU,oBACR;CAEJ,MAAM,6BAAa,IAAI,IAAY;CACnC,IAAI,gBAAgB;CACpB,IAAI,WAAW;CACf,IAAI,eAAe;CAEnB,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,QAAQ,UAAU,KAAK,QAAQ,KAAK,IAAI,GAAG,IAAI,IAAI,UAAU,GAAG,OAAO,GAAG;EACnF,IAAI;EACJ,IAAI;GACF,SAAS,aAAa,MAAM,MAAM;EACpC,QAAQ;GACN;EACF;EACA,gBAAgB;EAEhB,IAAI,CAAC,iBAAiB,WAAW,KAAK,MAAM,GAAG,gBAAgB;EAE/D,KAAK,MAAM,SAAS,OAAO,SAAS,eAAe,GAAG;GACpD,IAAI,MAAM,IAAI;GACd,IAAI,kBAAkB,MAAM,IAAK,UAAU,GAAG,WAAW;EAC3D;EAEA,KAAK,MAAM,SAAS,OAAO,SAAS,cAAc,GAChD,WAAW,IAAI,cAAc,MAAM,EAAG,CAAC;CAE3C;CAGF,OAAO;EAAE,YAAY,CAAC,GAAG,UAAU,CAAC,CAAC,KAAK;EAAG;EAAe;EAAc;CAAS;AACrF"}

package/es/static-css/shared.mjs

@@ -1,6 +1,5 @@
-//#region src/static-css/shared.ts
+// src/static-css/shared.ts
 const styleKeysOf = (cache) => [...cache.cache.keys()].filter((key) => key.startsWith("style%"));
-//#endregion
 export { styleKeysOf };
 
 //# sourceMappingURL=shared.mjs.map

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

@@ -1,5 +1,4 @@
 import { ThemeConfig } from "antd";
-//#region src/static-css/themeVars.d.ts
 type ThemeAppearance = 'dark' | 'light';
 interface ThemeVarsCssOptions {
   /** selector activating an appearance; default matches next-themes' data-theme attribute */
@@ -17,6 +16,5 @@ interface ThemeVarsCssPayload {
   skippedComponents: string[];
 }
 declare const buildThemeVarsCss: (options?: ThemeVarsCssOptions) => ThemeVarsCssPayload;
-//#endregion
 export { ThemeVarsCssOptions, ThemeVarsCssPayload, buildThemeVarsCss };
 //# sourceMappingURL=themeVars.d.mts.map

package/es/static-css/themeVars.mjs

@@ -4,7 +4,7 @@ import { createRequire } from "node:module";
 import { theme } from "antd";
 import { existsSync, readdirSync } from "node:fs";
 import path from "node:path";
-//#region src/static-css/themeVars.ts
+// src/static-css/themeVars.ts
 const require = createRequire(import.meta.url);
 const unitless = /* @__PURE__ */ new Set([
 	"fontWeightStrong",
@@ -106,7 +106,6 @@ const buildThemeVarsCss = (options = {}) => {
 		skippedComponents: componentVars.skipped
 	};
 };
-//#endregion
 export { buildThemeVarsCss, toKebabCase };
 
 //# sourceMappingURL=themeVars.mjs.map

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

@@ -1,7 +1,6 @@
 import { AntdStaticCssOptions } from "../buildAntdStaticCss.mjs";
 import { ThemeVarsCssOptions } from "../themeVars.mjs";
 import { Plugin } from "vite";
-//#region src/static-css/vite/index.d.ts
 declare const ANTD_STATIC_CSS_MODULE_ID = "virtual:lobehub/antd-static-css";
 declare const THEME_VARS_CSS_MODULE_ID = "virtual:lobehub/theme-vars-css";
 interface StaticCssPluginOptions {
@@ -9,6 +8,5 @@ interface StaticCssPluginOptions {
   themeVars?: ThemeVarsCssOptions | false;
 }
 declare const lobeStaticCssPlugin: (options?: StaticCssPluginOptions) => Plugin;
-//#endregion
 export { ANTD_STATIC_CSS_MODULE_ID, StaticCssPluginOptions, THEME_VARS_CSS_MODULE_ID, lobeStaticCssPlugin };
 //# sourceMappingURL=index.d.mts.map