@jinmi/ui 6.0.2 → 6.1.0

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/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/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

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

@@ -1,4 +1,4 @@
-//#region src/static-css/vite/index.ts
+// src/static-css/vite/index.ts
 const ANTD_STATIC_CSS_MODULE_ID = "virtual:lobehub/antd-static-css";
 const THEME_VARS_CSS_MODULE_ID = "virtual:lobehub/theme-vars-css";
 const moduleSource = (payload) => [...Object.entries(payload).map(([key, value]) => `export const ${key} = ${JSON.stringify(value)};`), `export default ${JSON.stringify(payload)};`].join("\n");
@@ -42,7 +42,6 @@ const lobeStaticCssPlugin = (options = {}) => {
 		}
 	};
 };
-//#endregion
 export { ANTD_STATIC_CSS_MODULE_ID, THEME_VARS_CSS_MODULE_ID, lobeStaticCssPlugin };
 
 //# sourceMappingURL=index.mjs.map

package/es/storybook/StoryBook/index.d.mts

@@ -2,13 +2,11 @@ import { FlexboxProps } from "../../Flex/type.mjs";
 import "../../Flex/index.mjs";
 import { Ref } from "react";
 import { useControls, useCreateStore } from "leva";
-//#region src/storybook/StoryBook/index.d.ts
 interface StoryBookProps extends FlexboxProps {
   levaStore: any;
   noPadding?: boolean;
   ref?: Ref<HTMLDivElement>;
 }
 declare const StoryBook: import("react").NamedExoticComponent<StoryBookProps>;
-//#endregion
 export { StoryBook, StoryBook as default, StoryBookProps, useControls, useCreateStore };
 //# sourceMappingURL=index.d.mts.map

package/es/storybook/StoryBook/index.mjs

@@ -7,7 +7,7 @@ import { memo } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { cx, useResponsive } from "antd-style";
 import { LevaPanel, useControls, useCreateStore } from "leva";
-//#region src/storybook/StoryBook/index.tsx
+// src/storybook/StoryBook/index.tsx
 const StoryBook = memo(({ ref, levaStore, noPadding, className, children, ...rest }) => {
 	const { mobile } = useResponsive();
 	return /* @__PURE__ */ jsxs(FlexBasic_default, {
@@ -42,7 +42,6 @@ const StoryBook = memo(({ ref, levaStore, noPadding, className, children, ...res
 	});
 });
 StoryBook.displayName = "StoryBook";
-//#endregion
 export { StoryBook, StoryBook as default, useControls, useCreateStore };
 
 //# sourceMappingURL=index.mjs.map

package/es/storybook/StoryBook/style.mjs

@@ -1,5 +1,5 @@
 import { createStaticStyles } from "antd-style";
-//#region src/storybook/StoryBook/style.ts
+// src/storybook/StoryBook/style.ts
 const styles = createStaticStyles(({ css, cssVar, responsive }) => {
 	return {
 		editor: css`
@@ -71,7 +71,6 @@ const styles = createStaticStyles(({ css, cssVar, responsive }) => {
     `
 	};
 });
-//#endregion
 export { styles };
 
 //# sourceMappingURL=style.mjs.map

package/es/storybook/index.mjs

@@ -1,2 +1 @@
-import { StoryBook, useControls, useCreateStore } from "./StoryBook/index.mjs";
-export { StoryBook, useControls, useCreateStore };
+export { StoryBook, useControls, useCreateStore } from "./StoryBook/index.mjs";

package/es/styles/animations.mjs

@@ -1,5 +1,5 @@
 import { keyframes } from "antd-style";
-//#region src/styles/animations.ts
+// src/styles/animations.ts
 const fadeIn = keyframes`
     0% {
       opacity: 0;
@@ -8,7 +8,6 @@ const fadeIn = keyframes`
       opacity: 1;
     }
 `;
-//#endregion
 export { fadeIn };
 
 //# sourceMappingURL=animations.mjs.map

package/es/styles/brandCssVar.d.mts

@@ -1,4 +1,3 @@
-//#region src/styles/brandCssVar.d.ts
 /**
  * CSS variables for the Jinmi brand tokens. antd-style's `cssVar` only maps antd's
  * own design tokens, so the brand tokens are emitted by `EssentialStyle` and read
@@ -11,6 +10,5 @@ declare const brandCssVar: {
   readonly colorBrandGlow: "var(--jinmi-color-brand-glow)";
   readonly colorBrandText: "var(--jinmi-color-brand-text)";
 };
-//#endregion
 export { brandCssVar };
 //# sourceMappingURL=brandCssVar.d.mts.map

package/es/styles/brandCssVar.mjs

@@ -1,4 +1,4 @@
-//#region src/styles/brandCssVar.ts
+// src/styles/brandCssVar.ts
 /**
 * CSS variables for the Jinmi brand tokens. antd-style's `cssVar` only maps antd's
 * own design tokens, so the brand tokens are emitted by `EssentialStyle` and read
@@ -11,7 +11,6 @@ const brandCssVar = {
 	colorBrandGlow: "var(--jinmi-color-brand-glow)",
 	colorBrandText: "var(--jinmi-color-brand-text)"
 };
-//#endregion
 export { brandCssVar };
 
 //# sourceMappingURL=brandCssVar.mjs.map