@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/jsdoc/createJSDocTypeExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocTypeExpression.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypeExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocTypeExpression}: a brace-wrapped JSDoc type.\n *\n * The `type` is the wrapped type. The printer surrounds it with curly braces,\n * producing the `{Type}` form that JSDoc tags use to carry their type.\n *\n * With a `number` type, the printer emits:\n *\n * ```ts\n * {number}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @returns The created {@link JSDocTypeExpression}.\n */\nexport const createJSDocTypeExpression = (type) => make(\"JSDocTypeExpression\", {\n    type,\n});\n//# sourceMappingURL=createJSDocTypeExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE;AAC/E,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/jsdoc/createJSDocTypeLiteral.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocTypeLiteral}: an object-shape type built from `@prop`
+ * tags.
+ *
+ * The `jsDocPropertyTags` are the member property tags, which the printer emits
+ * one per line. The `isArrayType` flag, when `true`, appends `[]` to mark the
+ * literal as an array of that shape.
+ *
+ * With a single `@prop {number} x` member tag and `isArrayType` of `false`, the
+ * printer emits:
+ *
+ * ```ts
+ * @prop {number} x
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param jsDocPropertyTags The member `@property` tags, if any.
+ * @param isArrayType Whether the literal represents an array of its type.
+ * @returns The created {@link JSDocTypeLiteral}.
+ */
+const createJSDocTypeLiteral = (jsDocPropertyTags, isArrayType = false) => make("JSDocTypeLiteral", {
+    jsDocPropertyTags,
+    isArrayType,
+});
+
+export { createJSDocTypeLiteral };
+//# sourceMappingURL=createJSDocTypeLiteral.mjs.map

package/lib/factory/jsdoc/createJSDocTypeLiteral.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocTypeLiteral.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypeLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocTypeLiteral}: an object-shape type built from `@prop`\n * tags.\n *\n * The `jsDocPropertyTags` are the member property tags, which the printer emits\n * one per line. The `isArrayType` flag, when `true`, appends `[]` to mark the\n * literal as an array of that shape.\n *\n * With a single `@prop {number} x` member tag and `isArrayType` of `false`, the\n * printer emits:\n *\n * ```ts\n * @prop {number} x\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param jsDocPropertyTags The member `@property` tags, if any.\n * @param isArrayType Whether the literal represents an array of its type.\n * @returns The created {@link JSDocTypeLiteral}.\n */\nexport const createJSDocTypeLiteral = (jsDocPropertyTags, isArrayType = false) => make(\"JSDocTypeLiteral\", {\n    jsDocPropertyTags,\n    isArrayType,\n});\n//# sourceMappingURL=createJSDocTypeLiteral.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,iBAAiB,EAAE,WAAW,GAAG,KAAK,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC3G,IAAI,iBAAiB;AACrB,IAAI,WAAW;AACf,CAAC;;;;"}

package/lib/factory/jsdoc/createJSDocTypeTag.mjs

@@ -0,0 +1,31 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocTypeTag}: a `@type` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `type` when omitted. The
+ * `typeExpression` supplies the brace-wrapped type, and `comment` is the
+ * trailing description, if any.
+ *
+ * With the default tag name and a `{number}` type expression, the printer
+ * emits:
+ *
+ * ```ts
+ * @type {number}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `type`.
+ * @param typeExpression The type expression.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocTypeTag}.
+ */
+const createJSDocTypeTag = (tagName, typeExpression, comment) => make("JSDocTypeTag", {
+    tagName: tagName ?? createIdentifier("type"),
+    typeExpression,
+    comment,
+});
+
+export { createJSDocTypeTag };
+//# sourceMappingURL=createJSDocTypeTag.mjs.map

package/lib/factory/jsdoc/createJSDocTypeTag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocTypeTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypeTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocTypeTag}: a `@type` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `type` when omitted. The\n * `typeExpression` supplies the brace-wrapped type, and `comment` is the\n * trailing description, if any.\n *\n * With the default tag name and a `{number}` type expression, the printer\n * emits:\n *\n * ```ts\n * @type {number}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `type`.\n * @param typeExpression The type expression.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocTypeTag}.\n */\nexport const createJSDocTypeTag = (tagName, typeExpression, comment) => make(\"JSDocTypeTag\", {\n    tagName: tagName ?? createIdentifier(\"type\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocTypeTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,cAAc,EAAE;AAC7F,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;AAChD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}

package/lib/factory/jsdoc/createJSDocTypedefTag.mjs

@@ -0,0 +1,34 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocTypedefTag}: a `@typedef` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `typedef` when omitted. The
+ * `typeExpression` is the aliased type, either a brace-wrapped type expression
+ * or a {@link JSDocTypeLiteral}. The `fullName` is the alias name, printed after
+ * the type, and `comment` is the trailing description.
+ *
+ * With the default tag name, a `{number}` type expression, and a `Count` name,
+ * the printer emits:
+ *
+ * ```ts
+ * @typedef {number} Count
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `typedef`.
+ * @param typeExpression The aliased type, if any.
+ * @param fullName The full alias name, if any.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocTypedefTag}.
+ */
+const createJSDocTypedefTag = (tagName, typeExpression, fullName, comment) => make("JSDocTypedefTag", {
+    tagName: tagName ?? createIdentifier("typedef"),
+    typeExpression,
+    fullName,
+    comment,
+});
+
+export { createJSDocTypedefTag };
+//# sourceMappingURL=createJSDocTypedefTag.mjs.map

package/lib/factory/jsdoc/createJSDocTypedefTag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocTypedefTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypedefTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocTypedefTag}: a `@typedef` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `typedef` when omitted. The\n * `typeExpression` is the aliased type, either a brace-wrapped type expression\n * or a {@link JSDocTypeLiteral}. The `fullName` is the alias name, printed after\n * the type, and `comment` is the trailing description.\n *\n * With the default tag name, a `{number}` type expression, and a `Count` name,\n * the printer emits:\n *\n * ```ts\n * @typedef {number} Count\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `typedef`.\n * @param typeExpression The aliased type, if any.\n * @param fullName The full alias name, if any.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocTypedefTag}.\n */\nexport const createJSDocTypedefTag = (tagName, typeExpression, fullName, comment) => make(\"JSDocTypedefTag\", {\n    tagName: tagName ?? createIdentifier(\"typedef\"),\n    typeExpression,\n    fullName,\n    comment,\n});\n//# sourceMappingURL=createJSDocTypedefTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE;AAC7G,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;AACnD,IAAI,cAAc;AAClB,IAAI,QAAQ;AACZ,IAAI,OAAO;AACX,CAAC;;;;"}

package/lib/factory/jsdoc/createJSDocUnknownTag.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocUnknownTag}: a JSDoc tag whose name is not one of the
+ * recognized tags.
+ *
+ * The `tagName` is the identifier after the `@`, and `comment` is the trailing
+ * text. This is the fallback node for any custom or unrecognized tag.
+ *
+ * With a tag name of `custom` and a `hello` comment, the printer emits:
+ *
+ * ```ts
+ * @custom hello
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocUnknownTag}.
+ */
+const createJSDocUnknownTag = (tagName, comment) => make("JSDocUnknownTag", {
+    tagName,
+    comment,
+});
+
+export { createJSDocUnknownTag };
+//# sourceMappingURL=createJSDocUnknownTag.mjs.map

package/lib/factory/jsdoc/createJSDocUnknownTag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocUnknownTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocUnknownTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocUnknownTag}: a JSDoc tag whose name is not one of the\n * recognized tags.\n *\n * The `tagName` is the identifier after the `@`, and `comment` is the trailing\n * text. This is the fallback node for any custom or unrecognized tag.\n *\n * With a tag name of `custom` and a `hello` comment, the printer emits:\n *\n * ```ts\n * @custom hello\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocUnknownTag}.\n */\nexport const createJSDocUnknownTag = (tagName, comment) => make(\"JSDocUnknownTag\", {\n    tagName,\n    comment,\n});\n//# sourceMappingURL=createJSDocUnknownTag.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE;AACnF,IAAI,OAAO;AACX,IAAI,OAAO;AACX,CAAC;;;;"}

package/lib/factory/jsdoc/createJSDocUnknownType.mjs

@@ -0,0 +1,21 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocUnknownType}: the JSDoc `?` unknown type.
+ *
+ * This node takes no inputs. It represents the unknown-type marker written as a
+ * bare question mark in a JSDoc type expression.
+ *
+ * The printer emits:
+ *
+ * ```ts
+ * ?
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link JSDocUnknownType}.
+ */
+const createJSDocUnknownType = () => make("JSDocUnknownType", {});
+
+export { createJSDocUnknownType };
+//# sourceMappingURL=createJSDocUnknownType.mjs.map

package/lib/factory/jsdoc/createJSDocUnknownType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocUnknownType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocUnknownType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocUnknownType}: the JSDoc `?` unknown type.\n *\n * This node takes no inputs. It represents the unknown-type marker written as a\n * bare question mark in a JSDoc type expression.\n *\n * The printer emits:\n *\n * ```ts\n * ?\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JSDocUnknownType}.\n */\nexport const createJSDocUnknownType = () => make(\"JSDocUnknownType\", {});\n//# sourceMappingURL=createJSDocUnknownType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,MAAM,IAAI,CAAC,kBAAkB,EAAE,EAAE;;;;"}

package/lib/factory/jsdoc/createJSDocVariadicType.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocVariadicType}: a JSDoc `...`-marked variadic type.
+ *
+ * The `type` is the wrapped element type. The printer prepends a `...` marker
+ * before it.
+ *
+ * With a `number` type, the printer emits:
+ *
+ * ```ts
+ * ...number
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The wrapped type.
+ * @returns The created {@link JSDocVariadicType}.
+ */
+const createJSDocVariadicType = (type) => make("JSDocVariadicType", {
+    type,
+});
+
+export { createJSDocVariadicType };
+//# sourceMappingURL=createJSDocVariadicType.mjs.map

package/lib/factory/jsdoc/createJSDocVariadicType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocVariadicType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocVariadicType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocVariadicType}: a JSDoc `...`-marked variadic type.\n *\n * The `type` is the wrapped element type. The printer prepends a `...` marker\n * before it.\n *\n * With a `number` type, the printer emits:\n *\n * ```ts\n * ...number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @returns The created {@link JSDocVariadicType}.\n */\nexport const createJSDocVariadicType = (type) => make(\"JSDocVariadicType\", {\n    type,\n});\n//# sourceMappingURL=createJSDocVariadicType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3E,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/jsx/createJsxAttribute.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxAttribute}: a single `name=value` prop on a JSX element.
+ *
+ * The name is a plain identifier or a {@link JsxNamespacedName} like
+ * `xlink:href`. The initializer is the value: a string literal, or a
+ * {@link JsxExpression} brace such as `{value}`. Pass `undefined` for a bare
+ * boolean-style attribute, which prints the name alone with no `=value`.
+ *
+ * Given the name `bar` and a string-literal initializer `"x"`, the printer
+ * emits:
+ *
+ * ```tsx
+ * bar = "x";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name.
+ * @param initializer The initializer, if any.
+ * @returns The created {@link JsxAttribute}.
+ */
+const createJsxAttribute = (name, initializer) => make("JsxAttribute", {
+    name,
+    initializer,
+});
+
+export { createJsxAttribute };
+//# sourceMappingURL=createJsxAttribute.mjs.map

package/lib/factory/jsx/createJsxAttribute.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxAttribute.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxAttribute.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxAttribute}: a single `name=value` prop on a JSX element.\n *\n * The name is a plain identifier or a {@link JsxNamespacedName} like\n * `xlink:href`. The initializer is the value: a string literal, or a\n * {@link JsxExpression} brace such as `{value}`. Pass `undefined` for a bare\n * boolean-style attribute, which prints the name alone with no `=value`.\n *\n * Given the name `bar` and a string-literal initializer `\"x\"`, the printer\n * emits:\n *\n * ```tsx\n * bar = \"x\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @param initializer The initializer, if any.\n * @returns The created {@link JsxAttribute}.\n */\nexport const createJsxAttribute = (name, initializer) => make(\"JsxAttribute\", {\n    name,\n    initializer,\n});\n//# sourceMappingURL=createJsxAttribute.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,cAAc,EAAE;AAC9E,IAAI,IAAI;AACR,IAAI,WAAW;AACf,CAAC;;;;"}

package/lib/factory/jsx/createJsxAttributes.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxAttributes}: the ordered collection of props on a JSX
+ * element.
+ *
+ * Each entry is either a {@link JsxAttribute} (`name=value`) or a
+ * {@link JsxSpreadAttribute} (`{...props}`). This node is what an opening or
+ * self-closing element holds as its `attributes`; an empty list prints to
+ * nothing.
+ *
+ * Printed on its own, the collection leads with a separating space before each
+ * attribute. Given a single `bar="x"` property, the printer emits (note the
+ * leading space):
+ *
+ * ```tsx
+ * bar = "x";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param properties The attribute properties.
+ * @returns The created {@link JsxAttributes}.
+ */
+const createJsxAttributes = (properties) => make("JsxAttributes", { properties });
+
+export { createJsxAttributes };
+//# sourceMappingURL=createJsxAttributes.mjs.map

package/lib/factory/jsx/createJsxAttributes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxAttributes.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxAttributes.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxAttributes}: the ordered collection of props on a JSX\n * element.\n *\n * Each entry is either a {@link JsxAttribute} (`name=value`) or a\n * {@link JsxSpreadAttribute} (`{...props}`). This node is what an opening or\n * self-closing element holds as its `attributes`; an empty list prints to\n * nothing.\n *\n * Printed on its own, the collection leads with a separating space before each\n * attribute. Given a single `bar=\"x\"` property, the printer emits (note the\n * leading space):\n *\n * ```tsx\n * bar = \"x\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param properties The attribute properties.\n * @returns The created {@link JsxAttributes}.\n */\nexport const createJsxAttributes = (properties) => make(\"JsxAttributes\", { properties });\n//# sourceMappingURL=createJsxAttributes.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/jsx/createJsxClosingElement.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxClosingElement}: the `</Tag>` that closes a paired
+ * {@link JsxElement}.
+ *
+ * This is the trailing half of a `<Tag>...</Tag>` pair. The tag name must match
+ * the one on the corresponding {@link JsxOpeningElement}; the factory does not
+ * enforce that, so the caller is responsible for passing the same name.
+ *
+ * Given the tag name `Foo`, the printer emits:
+ *
+ * ```tsx
+ * </Foo>
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name.
+ * @returns The created {@link JsxClosingElement}.
+ */
+const createJsxClosingElement = (tagName) => make("JsxClosingElement", { tagName });
+
+export { createJsxClosingElement };
+//# sourceMappingURL=createJsxClosingElement.mjs.map

package/lib/factory/jsx/createJsxClosingElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxClosingElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxClosingElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxClosingElement}: the `</Tag>` that closes a paired\n * {@link JsxElement}.\n *\n * This is the trailing half of a `<Tag>...</Tag>` pair. The tag name must match\n * the one on the corresponding {@link JsxOpeningElement}; the factory does not\n * enforce that, so the caller is responsible for passing the same name.\n *\n * Given the tag name `Foo`, the printer emits:\n *\n * ```tsx\n * </Foo>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @returns The created {@link JsxClosingElement}.\n */\nexport const createJsxClosingElement = (tagName) => make(\"JsxClosingElement\", { tagName });\n//# sourceMappingURL=createJsxClosingElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/jsx/createJsxElement.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxElement}: a paired `<Tag>...</Tag>` element with children.
+ *
+ * The element is built from three already-created pieces: the
+ * {@link JsxOpeningElement} that carries the tag name and attributes, the list
+ * of children rendered between the tags, and the {@link JsxClosingElement} that
+ * repeats the tag name. The children may be {@link JsxText}, nested elements,
+ * fragments, or {@link JsxExpression} braces, in source order.
+ *
+ * Given an opening `<Foo bar="x">`, a single `Hello` text child, and a closing
+ * `</Foo>`, the printer emits:
+ *
+ * ```tsx
+ * <Foo bar="x">Hello</Foo>
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param openingElement The opening element.
+ * @param children The children.
+ * @param closingElement The closing element.
+ * @returns The created {@link JsxElement}.
+ */
+const createJsxElement = (openingElement, children, closingElement) => make("JsxElement", {
+    openingElement,
+    children,
+    closingElement,
+});
+
+export { createJsxElement };
+//# sourceMappingURL=createJsxElement.mjs.map

package/lib/factory/jsx/createJsxElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxElement}: a paired `<Tag>...</Tag>` element with children.\n *\n * The element is built from three already-created pieces: the\n * {@link JsxOpeningElement} that carries the tag name and attributes, the list\n * of children rendered between the tags, and the {@link JsxClosingElement} that\n * repeats the tag name. The children may be {@link JsxText}, nested elements,\n * fragments, or {@link JsxExpression} braces, in source order.\n *\n * Given an opening `<Foo bar=\"x\">`, a single `Hello` text child, and a closing\n * `</Foo>`, the printer emits:\n *\n * ```tsx\n * <Foo bar=\"x\">Hello</Foo>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param openingElement The opening element.\n * @param children The children.\n * @param closingElement The closing element.\n * @returns The created {@link JsxElement}.\n */\nexport const createJsxElement = (openingElement, children, closingElement) => make(\"JsxElement\", {\n    openingElement,\n    children,\n    closingElement,\n});\n//# sourceMappingURL=createJsxElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,cAAc,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC,YAAY,EAAE;AACjG,IAAI,cAAc;AAClB,IAAI,QAAQ;AACZ,IAAI,cAAc;AAClB,CAAC;;;;"}

package/lib/factory/jsx/createJsxExpression.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxExpression}: a `{...}` brace embedding a JavaScript
+ * expression in JSX.
+ *
+ * This is how a dynamic value is dropped into a child position or an attribute
+ * value. Pass the `expression` to render inside the braces; pass `undefined`
+ * for an empty `{}`. The optional `dotDotDotToken` (the `...` token) turns it
+ * into a spread child, prefixing the expression with `...` inside the braces.
+ *
+ * Given no spread token and the expression `value`, the printer emits:
+ *
+ * ```tsx
+ * {value}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param dotDotDotToken The `...` token, if a spread.
+ * @param expression The expression, if any.
+ * @returns The created {@link JsxExpression}.
+ */
+const createJsxExpression = (dotDotDotToken, expression) => make("JsxExpression", {
+    dotDotDotToken,
+    expression,
+});
+
+export { createJsxExpression };
+//# sourceMappingURL=createJsxExpression.mjs.map

package/lib/factory/jsx/createJsxExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxExpression.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxExpression}: a `{...}` brace embedding a JavaScript\n * expression in JSX.\n *\n * This is how a dynamic value is dropped into a child position or an attribute\n * value. Pass the `expression` to render inside the braces; pass `undefined`\n * for an empty `{}`. The optional `dotDotDotToken` (the `...` token) turns it\n * into a spread child, prefixing the expression with `...` inside the braces.\n *\n * Given no spread token and the expression `value`, the printer emits:\n *\n * ```tsx\n * {value}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param dotDotDotToken The `...` token, if a spread.\n * @param expression The expression, if any.\n * @returns The created {@link JsxExpression}.\n */\nexport const createJsxExpression = (dotDotDotToken, expression) => make(\"JsxExpression\", {\n    dotDotDotToken,\n    expression,\n});\n//# sourceMappingURL=createJsxExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,cAAc,EAAE,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE;AACzF,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,CAAC;;;;"}

package/lib/factory/jsx/createJsxFragment.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxFragment}: a `<>...</>` fragment grouping children without
+ * a wrapping element.
+ *
+ * The fragment is built from an empty {@link JsxOpeningFragment} (`<>`), the
+ * list of children, and an empty {@link JsxClosingFragment} (`</>`). It exists
+ * to render several siblings where a single root is required, without emitting
+ * an extra DOM tag. The children follow the same rules as a {@link JsxElement}.
+ *
+ * Given an opening fragment, a single `Hello` text child, and a closing
+ * fragment, the printer emits:
+ *
+ * ```tsx
+ * <>Hello</>
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param openingFragment The opening fragment.
+ * @param children The children.
+ * @param closingFragment The closing fragment.
+ * @returns The created {@link JsxFragment}.
+ */
+const createJsxFragment = (openingFragment, children, closingFragment) => make("JsxFragment", {
+    openingFragment,
+    children,
+    closingFragment,
+});
+
+export { createJsxFragment };
+//# sourceMappingURL=createJsxFragment.mjs.map

package/lib/factory/jsx/createJsxFragment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxFragment.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxFragment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxFragment}: a `<>...</>` fragment grouping children without\n * a wrapping element.\n *\n * The fragment is built from an empty {@link JsxOpeningFragment} (`<>`), the\n * list of children, and an empty {@link JsxClosingFragment} (`</>`). It exists\n * to render several siblings where a single root is required, without emitting\n * an extra DOM tag. The children follow the same rules as a {@link JsxElement}.\n *\n * Given an opening fragment, a single `Hello` text child, and a closing\n * fragment, the printer emits:\n *\n * ```tsx\n * <>Hello</>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param openingFragment The opening fragment.\n * @param children The children.\n * @param closingFragment The closing fragment.\n * @returns The created {@link JsxFragment}.\n */\nexport const createJsxFragment = (openingFragment, children, closingFragment) => make(\"JsxFragment\", {\n    openingFragment,\n    children,\n    closingFragment,\n});\n//# sourceMappingURL=createJsxFragment.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,eAAe,EAAE,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC,aAAa,EAAE;AACrG,IAAI,eAAe;AACnB,IAAI,QAAQ;AACZ,IAAI,eAAe;AACnB,CAAC;;;;"}

package/lib/factory/jsx/createJsxJsxClosingFragment.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxClosingFragment}: the `</>` that closes a
+ * {@link JsxFragment}.
+ *
+ * It takes no arguments and is the empty trailing delimiter of a `<>...</>`
+ * pair. Pair it with a {@link JsxOpeningFragment} through
+ * {@link createJsxFragment}.
+ *
+ * With no inputs, the printer emits:
+ *
+ * ```tsx
+ * </>
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link JsxClosingFragment}.
+ */
+const createJsxJsxClosingFragment = () => make("JsxClosingFragment", {});
+
+export { createJsxJsxClosingFragment };
+//# sourceMappingURL=createJsxJsxClosingFragment.mjs.map

package/lib/factory/jsx/createJsxJsxClosingFragment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxJsxClosingFragment.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxJsxClosingFragment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxClosingFragment}: the `</>` that closes a\n * {@link JsxFragment}.\n *\n * It takes no arguments and is the empty trailing delimiter of a `<>...</>`\n * pair. Pair it with a {@link JsxOpeningFragment} through\n * {@link createJsxFragment}.\n *\n * With no inputs, the printer emits:\n *\n * ```tsx\n * </>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JsxClosingFragment}.\n */\nexport const createJsxJsxClosingFragment = () => make(\"JsxClosingFragment\", {});\n//# sourceMappingURL=createJsxJsxClosingFragment.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,MAAM,IAAI,CAAC,oBAAoB,EAAE,EAAE;;;;"}

package/lib/factory/jsx/createJsxNamespacedName.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxNamespacedName}: a colon-separated `namespace:name` used in
+ * tag or attribute names.
+ *
+ * Both parts are identifiers; the result reads `namespace:name`. It appears
+ * where namespaced JSX names are valid, most commonly as an attribute name such
+ * as `xlink:href` on an SVG element, or as a namespaced tag name.
+ *
+ * Given the namespace `ns` and the name `name`, the printer emits:
+ *
+ * ```tsx
+ * ns: name;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param namespace The namespace.
+ * @param name The name.
+ * @returns The created {@link JsxNamespacedName}.
+ */
+const createJsxNamespacedName = (namespace, name) => make("JsxNamespacedName", {
+    namespace,
+    name,
+});
+
+export { createJsxNamespacedName };
+//# sourceMappingURL=createJsxNamespacedName.mjs.map

package/lib/factory/jsx/createJsxNamespacedName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxNamespacedName.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxNamespacedName.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxNamespacedName}: a colon-separated `namespace:name` used in\n * tag or attribute names.\n *\n * Both parts are identifiers; the result reads `namespace:name`. It appears\n * where namespaced JSX names are valid, most commonly as an attribute name such\n * as `xlink:href` on an SVG element, or as a namespaced tag name.\n *\n * Given the namespace `ns` and the name `name`, the printer emits:\n *\n * ```tsx\n * ns: name;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param namespace The namespace.\n * @param name The name.\n * @returns The created {@link JsxNamespacedName}.\n */\nexport const createJsxNamespacedName = (namespace, name) => make(\"JsxNamespacedName\", {\n    namespace,\n    name,\n});\n//# sourceMappingURL=createJsxNamespacedName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACtF,IAAI,SAAS;AACb,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/jsx/createJsxOpeningElement.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxOpeningElement}: the `<Tag>` that opens a paired
+ * {@link JsxElement}.
+ *
+ * This is the leading half of a `<Tag>...</Tag>` pair; it carries the tag name,
+ * optional generic `typeArguments`, and the attributes, but no children and no
+ * trailing slash. Pair it with a matching {@link JsxClosingElement} through
+ * {@link createJsxElement}.
+ *
+ * Given the tag name `Foo`, no type arguments, and attributes holding a single
+ * `bar="x"`, the printer emits:
+ *
+ * ```tsx
+ * <Foo bar="x">
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name.
+ * @param typeArguments The generic type arguments, if any.
+ * @param attributes The attributes.
+ * @returns The created {@link JsxOpeningElement}.
+ */
+const createJsxOpeningElement = (tagName, typeArguments, attributes) => make("JsxOpeningElement", {
+    tagName,
+    typeArguments,
+    attributes,
+});
+
+export { createJsxOpeningElement };
+//# sourceMappingURL=createJsxOpeningElement.mjs.map

package/lib/factory/jsx/createJsxOpeningElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxOpeningElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxOpeningElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxOpeningElement}: the `<Tag>` that opens a paired\n * {@link JsxElement}.\n *\n * This is the leading half of a `<Tag>...</Tag>` pair; it carries the tag name,\n * optional generic `typeArguments`, and the attributes, but no children and no\n * trailing slash. Pair it with a matching {@link JsxClosingElement} through\n * {@link createJsxElement}.\n *\n * Given the tag name `Foo`, no type arguments, and attributes holding a single\n * `bar=\"x\"`, the printer emits:\n *\n * ```tsx\n * <Foo bar=\"x\">\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param typeArguments The generic type arguments, if any.\n * @param attributes The attributes.\n * @returns The created {@link JsxOpeningElement}.\n */\nexport const createJsxOpeningElement = (tagName, typeArguments, attributes) => make(\"JsxOpeningElement\", {\n    tagName,\n    typeArguments,\n    attributes,\n});\n//# sourceMappingURL=createJsxOpeningElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACzG,IAAI,OAAO;AACX,IAAI,aAAa;AACjB,IAAI,UAAU;AACd,CAAC;;;;"}

package/lib/factory/jsx/createJsxOpeningFragment.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxOpeningFragment}: the `<>` that opens a {@link JsxFragment}.
+ *
+ * It takes no arguments and carries no tag name or attributes; it is the empty
+ * leading delimiter of a `<>...</>` pair. Pair it with a
+ * {@link JsxClosingFragment} through {@link createJsxFragment}.
+ *
+ * With no inputs, the printer emits:
+ *
+ * ```tsx
+ * <>
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link JsxOpeningFragment}.
+ */
+const createJsxOpeningFragment = () => make("JsxOpeningFragment", {});
+
+export { createJsxOpeningFragment };
+//# sourceMappingURL=createJsxOpeningFragment.mjs.map

package/lib/factory/jsx/createJsxOpeningFragment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxOpeningFragment.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxOpeningFragment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxOpeningFragment}: the `<>` that opens a {@link JsxFragment}.\n *\n * It takes no arguments and carries no tag name or attributes; it is the empty\n * leading delimiter of a `<>...</>` pair. Pair it with a\n * {@link JsxClosingFragment} through {@link createJsxFragment}.\n *\n * With no inputs, the printer emits:\n *\n * ```tsx\n * <>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JsxOpeningFragment}.\n */\nexport const createJsxOpeningFragment = () => make(\"JsxOpeningFragment\", {});\n//# sourceMappingURL=createJsxOpeningFragment.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,MAAM,IAAI,CAAC,oBAAoB,EAAE,EAAE;;;;"}

package/lib/factory/jsx/createJsxSelfClosingElement.mjs

@@ -0,0 +1,31 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxSelfClosingElement}: a `<Tag />` element with no children.
+ *
+ * The tag name accepts a plain identifier, a property-access chain like
+ * `Foo.Bar`, or a {@link JsxNamespacedName}. Optional `typeArguments` render as
+ * a generic argument list right after the tag name. The attributes carry the
+ * element's props; pass an empty {@link JsxAttributes} for none.
+ *
+ * Given the tag name `Foo`, no type arguments, and attributes holding a single
+ * `bar="x"`, the printer emits:
+ *
+ * ```tsx
+ * <Foo bar="x" />
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name.
+ * @param typeArguments The generic type arguments, if any.
+ * @param attributes The attributes.
+ * @returns The created {@link JsxSelfClosingElement}.
+ */
+const createJsxSelfClosingElement = (tagName, typeArguments, attributes) => make("JsxSelfClosingElement", {
+    tagName,
+    typeArguments,
+    attributes,
+});
+
+export { createJsxSelfClosingElement };
+//# sourceMappingURL=createJsxSelfClosingElement.mjs.map

package/lib/factory/jsx/createJsxSelfClosingElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxSelfClosingElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxSelfClosingElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxSelfClosingElement}: a `<Tag />` element with no children.\n *\n * The tag name accepts a plain identifier, a property-access chain like\n * `Foo.Bar`, or a {@link JsxNamespacedName}. Optional `typeArguments` render as\n * a generic argument list right after the tag name. The attributes carry the\n * element's props; pass an empty {@link JsxAttributes} for none.\n *\n * Given the tag name `Foo`, no type arguments, and attributes holding a single\n * `bar=\"x\"`, the printer emits:\n *\n * ```tsx\n * <Foo bar=\"x\" />\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param typeArguments The generic type arguments, if any.\n * @param attributes The attributes.\n * @returns The created {@link JsxSelfClosingElement}.\n */\nexport const createJsxSelfClosingElement = (tagName, typeArguments, attributes) => make(\"JsxSelfClosingElement\", {\n    tagName,\n    typeArguments,\n    attributes,\n});\n//# sourceMappingURL=createJsxSelfClosingElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,uBAAuB,EAAE;AACjH,IAAI,OAAO;AACX,IAAI,aAAa;AACjB,IAAI,UAAU;AACd,CAAC;;;;"}

package/lib/factory/jsx/createJsxSpreadAttribute.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JsxSpreadAttribute}: a `{...expr}` prop that spreads an
+ * object's members onto a JSX element.
+ *
+ * The expression evaluates to the object whose own properties become
+ * attributes. It sits among ordinary {@link JsxAttribute} entries inside a
+ * {@link JsxAttributes} list.
+ *
+ * Given the expression `props`, the printer emits:
+ *
+ * ```tsx
+ * {...props}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @returns The created {@link JsxSpreadAttribute}.
+ */
+const createJsxSpreadAttribute = (expression) => make("JsxSpreadAttribute", { expression });
+
+export { createJsxSpreadAttribute };
+//# sourceMappingURL=createJsxSpreadAttribute.mjs.map

package/lib/factory/jsx/createJsxSpreadAttribute.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJsxSpreadAttribute.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxSpreadAttribute.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxSpreadAttribute}: a `{...expr}` prop that spreads an\n * object's members onto a JSX element.\n *\n * The expression evaluates to the object whose own properties become\n * attributes. It sits among ordinary {@link JsxAttribute} entries inside a\n * {@link JsxAttributes} list.\n *\n * Given the expression `props`, the printer emits:\n *\n * ```tsx\n * {...props}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression.\n * @returns The created {@link JsxSpreadAttribute}.\n */\nexport const createJsxSpreadAttribute = (expression) => make(\"JsxSpreadAttribute\", { expression });\n//# sourceMappingURL=createJsxSpreadAttribute.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,UAAU,EAAE;;;;"}