@alloy-js/core 0.23.0-dev.13 → 0.23.0-dev.15

package/docs/api/functions/getDiagnosticsForTree.md

@@ -0,0 +1,18 @@
+# getDiagnosticsForTree
+
+```ts
+import { getDiagnosticsForTree } from "@alloy-js/core";
+
+
+function getDiagnosticsForTree(tree: RenderedTextTree): import("./diagnostics.js").Diagnostic[];
+```
+
+## Parameters
+
+|      |                  |   |
+| ---- | ---------------- | - |
+| tree | RenderedTextTree |   |
+
+## Returns
+
+import(”./diagnostics.js”).[Diagnostic](../../types/diagnostic/)\[]

package/docs/api/functions/getEffectDebugId.md

@@ -0,0 +1,18 @@
+# getEffectDebugId
+
+```ts
+import { getEffectDebugId } from "@alloy-js/core";
+
+
+function getEffectDebugId(effect: object): number | undefined;
+```
+
+## Parameters
+
+|        |        |   |
+| ------ | ------ | - |
+| effect | object |   |
+
+## Returns
+
+number | undefined

package/docs/api/functions/getElementCache.md

@@ -0,0 +1,17 @@
+# getElementCache
+
+```ts
+import { getElementCache } from "@alloy-js/core";
+
+
+function getElementCache(): Map<any, any>;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+Map\<any, any>

package/docs/api/functions/getReactiveCreationLocation.md

@@ -0,0 +1,18 @@
+# getReactiveCreationLocation
+
+```ts
+import { getReactiveCreationLocation } from "@alloy-js/core";
+
+
+function getReactiveCreationLocation(target: object): import("./devtools-entry.browser.js").SourceLocation | undefined;
+```
+
+## Parameters
+
+|        |        |   |
+| ------ | ------ | - |
+| target | object |   |
+
+## Returns
+
+import(”./devtools-entry.browser.js”).SourceLocation | undefined

package/docs/api/functions/getSymbolCreator.md

@@ -0,0 +1,18 @@
+# getSymbolCreator
+
+```ts
+import { getSymbolCreator } from "@alloy-js/core";
+
+
+function getSymbolCreator(creator: SymbolCreator): SymbolCreator[typeof createSymbolsSymbol];
+```
+
+## Parameters
+
+|         |               |   |
+| ------- | ------------- | - |
+| creator | SymbolCreator |   |
+
+## Returns
+
+[SymbolCreator](../../types/symbolcreator/)\[typeof createSymbolsSymbol]

package/docs/api/functions/getSymbolCreatorSymbol.md

@@ -0,0 +1,17 @@
+# getSymbolCreatorSymbol
+
+```ts
+import { getSymbolCreatorSymbol } from "@alloy-js/core";
+
+
+function getSymbolCreatorSymbol(): typeof createSymbolsSymbol;
+```
+
+## Parameters
+
+|   |
+| - |
+
+## Returns
+
+typeof createSymbolsSymbol

package/docs/api/functions/index.md

@@ -0,0 +1,105 @@
+# core — functions
+
+- [attachDiagnosticsCollector](attachDiagnosticsCollector.md) — import { attachDiagnosticsCollector } from "@alloy-js/core";
+- [baseListPropsToMapJoinArgs](baseListPropsToMapJoinArgs.md) — Convert a list of props to a joiner and ender for use in [mapJoin](../mapjoin/).
+- [children](children.md) — Returns a memo which is a list of all the provided children.
+- [childrenArray](childrenArray.md) — import { childrenArray } from "@alloy-js/core";
+- [code](code.md) — Turn the provided string template into Children by replacing literal line breaks with hardlines and automatically indenting indented content.
+- [computed](computed.md) — import { computed } from "@alloy-js/core";
+- [createComponent](createComponent.md) — import { createComponent } from "@alloy-js/core";
+- [createContentSlot](createContentSlot.md) — Create a component which tracks whether any content is placed inside of it.
+- [createContext](createContext.md) — import { createContext } from "@alloy-js/core";
+- [createCustomContext](createCustomContext.md) — import { createCustomContext } from "@alloy-js/core";
+- [createDeclarationTap](createDeclarationTap.md) — Create a tap for [Declaration context](../../contexts/declaration-context/).
+- [createFileResource](createFileResource.md) — Create a resource that reads a file from the file system.
+- [createFormatOptionsContextFor](createFormatOptionsContextFor.md) — Create a format options context for a specific file type.
+- [createIntrinsic](createIntrinsic.md) — import { createIntrinsic } from "@alloy-js/core";
+- [createMemberTap](createMemberTap.md) — Create a tap for [MemberDeclaration context](../../contexts/memberdeclaration-context/).
+- [createNamedContext](createNamedContext.md) — import { createNamedContext } from "@alloy-js/core";
+- [createNamePolicy](createNamePolicy.md) — Creates a name policy that transforms symbol names based on element kind.
+- [createOutputBinder](createOutputBinder.md) — import { createOutputBinder } from "@alloy-js/core";
+- [createRenderTreeHook](createRenderTreeHook.md) — import { createRenderTreeHook } from "@alloy-js/core";
+- [createResource](createResource.md) — Create a resource that fetches data asynchronously.
+- [createScope](createScope.md) — Construct a scope instance and register it with devtools.
+- [createScopeTap](createScopeTap.md) — Create a tap for [OutputScope](../../types/outputscope/).
+- [createSourceFileTap](createSourceFileTap.md) — Create a tap for [SourceFile context interface](../../contexts/sourcefile-context/).
+- [createSymbol](createSymbol.md) — Construct a symbol instance and register it with devtools.
+- [createSymbolSlot](createSymbolSlot.md) — Create a component which accepts emitted symbols.
+- [createTap](createTap.md) — Create a component that when rendered, initializes the tapped value with the provided callback.
+- [decl](decl.md) — Create a declaration in the current scope with the given namekey.
+- [defaultProps](defaultProps.md) — Applies default values to a props object.
+- [effect](effect.md) — import { effect } from "@alloy-js/core";
+- [emitDiagnostic](emitDiagnostic.md) — import { emitDiagnostic } from "@alloy-js/core";
+- [emitSymbol](emitSymbol.md) — import { emitSymbol } from "@alloy-js/core";
+- [ensureIsEmpty](ensureIsEmpty.md) — Ensure that a context has an isEmpty ref, creating one if needed.
+- [findCurrentEffectId](findCurrentEffectId.md) — Walk up the context owner chain to find the nearest effect ID.
+- [findKeyedChild](findKeyedChild.md) — import { findKeyedChild } from "@alloy-js/core";
+- [findKeyedChildren](findKeyedChildren.md) — import { findKeyedChildren } from "@alloy-js/core";
+- [findUnkeyedChildren](findUnkeyedChildren.md) — import { findUnkeyedChildren } from "@alloy-js/core";
+- [formatReactivePropertyLabel](formatReactivePropertyLabel.md) — Build a human-readable label for a reactive property like `symbolName.prop`.
+- [getAssignmentSymbol](getAssignmentSymbol.md) — Get the symbol being defined.
+- [getContext](getContext.md) — import { getContext } from "@alloy-js/core";
+- [getContextForRenderNode](getContextForRenderNode.md) — import { getContextForRenderNode } from "@alloy-js/core";
+- [getDiagnosticsForTree](getDiagnosticsForTree.md) — import { getDiagnosticsForTree } from "@alloy-js/core";
+- [getEffectDebugId](getEffectDebugId.md) — import { getEffectDebugId } from "@alloy-js/core";
+- [getElementCache](getElementCache.md) — import { getElementCache } from "@alloy-js/core";
+- [getReactiveCreationLocation](getReactiveCreationLocation.md) — import { getReactiveCreationLocation } from "@alloy-js/core";
+- [getSymbolCreator](getSymbolCreator.md) — import { getSymbolCreator } from "@alloy-js/core";
+- [getSymbolCreatorSymbol](getSymbolCreatorSymbol.md) — import { getSymbolCreatorSymbol } from "@alloy-js/core";
+- [inspectRefkey](inspectRefkey.md) — import { inspectRefkey } from "@alloy-js/core";
+- [instantiateTakenMembersTo](instantiateTakenMembersTo.md) — import { instantiateTakenMembersTo } from "@alloy-js/core";
+- [isComponentCreator](isComponentCreator.md) — import { isComponentCreator } from "@alloy-js/core";
+- [isCustomContext](isCustomContext.md) — import { isCustomContext } from "@alloy-js/core";
+- [isIntrinsicElement](isIntrinsicElement.md) — import { isIntrinsicElement } from "@alloy-js/core";
+- [isKeyedChild](isKeyedChild.md) — import { isKeyedChild } from "@alloy-js/core";
+- [isLibrarySymbolReference](isLibrarySymbolReference.md) — import { isLibrarySymbolReference } from "@alloy-js/core";
+- [isMemberRefkey](isMemberRefkey.md) — import { isMemberRefkey } from "@alloy-js/core";
+- [isNamekey](isNamekey.md) — import { isNamekey } from "@alloy-js/core";
+- [isPrintHook](isPrintHook.md) — import { isPrintHook } from "@alloy-js/core";
+- [isRefkey](isRefkey.md) — import { isRefkey } from "@alloy-js/core";
+- [isRefkeyable](isRefkeyable.md) — import { isRefkeyable } from "@alloy-js/core";
+- [isRenderableObject](isRenderableObject.md) — Returns true if the item is a renderable object, meaning it has an `[ay.RENDERABLE]` method.
+- [isSymbolRefkey](isSymbolRefkey.md) — import { isSymbolRefkey } from "@alloy-js/core";
+- [join](join.md) — Place a joiner between each element of an array or iterator.
+- [mapJoin](mapJoin.md) — Map a Map to an array using a mapper and place a joiner between each element.
+- [memberRefkey](memberRefkey.md) — Create a refkey for an instantiation of a symbol.
+- [memo](memo.md) — Returns a getter caching the result of `fn`.
+- [mergeProps](mergeProps.md) — import { mergeProps } from "@alloy-js/core";
+- [moveTakenMembersTo](moveTakenMembersTo.md) — import { moveTakenMembersTo } from "@alloy-js/core";
+- [namekey](namekey.md) — Create a namekey with the given name.
+- [nextReactiveId](nextReactiveId.md) — Allocate a unique reactive target ID from the same counter space as ref IDs.
+- [notifyContentState](notifyContentState.md) — import { notifyContentState } from "@alloy-js/core";
+- [onCleanup](onCleanup.md) — Register a cleanup function which is called when the current reactive scope is recalculated or disposed.
+- [printTree](printTree.md) — Convert a rendered text tree to a string.
+- [reactivePropertyRefId](reactivePropertyRefId.md) — Get a stable ref ID for a property of a reactive object.
+- [ref](ref.md) — import { ref } from "@alloy-js/core";
+- [refId](refId.md) — import { refId } from "@alloy-js/core";
+- [refkey](refkey.md) — Create a refkey for the provided arguments.
+- [render](render.md) — Render a component tree to source directories and files.
+- [renderAsync](renderAsync.md) — Render a component tree to source directories and files.
+- [renderTree](renderTree.md) — import { renderTree } from "@alloy-js/core";
+- [reportDiagnostics](reportDiagnostics.md) — import { reportDiagnostics } from "@alloy-js/core";
+- [resetRefIdCounter](resetRefIdCounter.md) — import { resetRefIdCounter } from "@alloy-js/core";
+- [resolve](resolve.md) — Resolve a refkey in the current scope.
+- [root](root.md) — import { root } from "@alloy-js/core";
+- [shallowReactive](shallowReactive.md) — import { shallowReactive } from "@alloy-js/core";
+- [shallowRef](shallowRef.md) — import { shallowRef } from "@alloy-js/core";
+- [sourceFilesForTree](sourceFilesForTree.md) — Convert a rendered text tree to source directories and files.
+- [splitProps](splitProps.md) — import { splitProps } from "@alloy-js/core";
+- [stc](stc.md) — import { stc } from "@alloy-js/core";
+- [sti](sti.md) — import { sti } from "@alloy-js/core";
+- [symbolForRefkey](symbolForRefkey.md) — Get a ref to the symbol for the given refkey using the current binder.
+- [taggedComponent](taggedComponent.md) — import { taggedComponent } from "@alloy-js/core";
+- [takeSymbols](takeSymbols.md) — import { takeSymbols } from "@alloy-js/core";
+- [text](text.md) — import { text } from "@alloy-js/core";
+- [toRef](toRef.md) — import { toRef } from "@alloy-js/core";
+- [toRefkey](toRefkey.md) — import { toRefkey } from "@alloy-js/core";
+- [toRefs](toRefs.md) — import { toRefs } from "@alloy-js/core";
+- [traverseOutput](traverseOutput.md) — Traverse the output from [render](../render/) and call the visitor for each file and directory within it.
+- [unresolvedRefkey](unresolvedRefkey.md) — import { unresolvedRefkey } from "@alloy-js/core";
+- [untrack](untrack.md) — import { untrack } from "@alloy-js/core";
+- [useContext](useContext.md) — import { useContext } from "@alloy-js/core";
+- [useFormatOptions](useFormatOptions.md) — import { useFormatOptions } from "@alloy-js/core";
+- [useMemberContext](useMemberContext.md) — import { useMemberContext } from "@alloy-js/core";
+- [useMemberScope](useMemberScope.md) — import { useMemberScope } from "@alloy-js/core";
+- [writeOutput](writeOutput.md) — Write the output from [render](../render/) to the file system.

package/docs/api/functions/inspectRefkey.md

@@ -0,0 +1,18 @@
+# inspectRefkey
+
+```ts
+import { inspectRefkey } from "@alloy-js/core";
+
+
+function inspectRefkey(refkey: Refkey): string;
+```
+
+## Parameters
+
+|        |        |   |
+| ------ | ------ | - |
+| refkey | Refkey |   |
+
+## Returns
+
+string

package/docs/api/functions/instantiateTakenMembersTo.md

@@ -0,0 +1,20 @@
+# instantiateTakenMembersTo
+
+```ts
+import { instantiateTakenMembersTo } from "@alloy-js/core";
+
+
+function instantiateTakenMembersTo(baseSymbol: OutputSymbol, toSpaceKey: string, fromSpaceKey: string): void;
+```
+
+## Parameters
+
+|              |              |   |
+| ------------ | ------------ | - |
+| baseSymbol   | OutputSymbol |   |
+| toSpaceKey   | string       |   |
+| fromSpaceKey | string       |   |
+
+## Returns
+
+void

package/docs/api/functions/isComponentCreator.md

@@ -0,0 +1,19 @@
+# isComponentCreator
+
+```ts
+import { isComponentCreator } from "@alloy-js/core";
+
+
+function isComponentCreator<TProps = any>(item: unknown, component?: Component<TProps>): item is ComponentCreator<TProps>;
+```
+
+## Parameters
+
+|           |                             |   |
+| --------- | --------------------------- | - |
+| item      | unknown                     |   |
+| component | optional Component\<TProps> |   |
+
+## Returns
+
+item is [ComponentCreator](../../types/componentcreator/)\<TProps>

package/docs/api/functions/isCustomContext.md

@@ -0,0 +1,18 @@
+# isCustomContext
+
+```ts
+import { isCustomContext } from "@alloy-js/core";
+
+
+function isCustomContext(child: Children): child is CustomContext;
+```
+
+## Parameters
+
+|       |          |   |
+| ----- | -------- | - |
+| child | Children |   |
+
+## Returns
+
+child is [CustomContext](../../types/customcontext/)

package/docs/api/functions/isIntrinsicElement.md

@@ -0,0 +1,18 @@
+# isIntrinsicElement
+
+```ts
+import { isIntrinsicElement } from "@alloy-js/core";
+
+
+function isIntrinsicElement(type: unknown): type is IntrinsicElement;
+```
+
+## Parameters
+
+|      |         |   |
+| ---- | ------- | - |
+| type | unknown |   |
+
+## Returns
+
+type is [IntrinsicElement](../../types/intrinsicelement/)

package/docs/api/functions/isKeyedChild.md

@@ -0,0 +1,18 @@
+# isKeyedChild
+
+```ts
+import { isKeyedChild } from "@alloy-js/core";
+
+
+function isKeyedChild(child: Children): child is ComponentCreator;
+```
+
+## Parameters
+
+|       |          |   |
+| ----- | -------- | - |
+| child | Children |   |
+
+## Returns
+
+child is [ComponentCreator](../../types/componentcreator/)

package/docs/api/functions/isLibrarySymbolReference.md

@@ -0,0 +1,18 @@
+# isLibrarySymbolReference
+
+```ts
+import { isLibrarySymbolReference } from "@alloy-js/core";
+
+
+function isLibrarySymbolReference(value: unknown): value is LibrarySymbolReference;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| value | unknown |   |
+
+## Returns
+
+value is [LibrarySymbolReference](../../types/librarysymbolreference/)

package/docs/api/functions/isMemberRefkey.md

@@ -0,0 +1,18 @@
+# isMemberRefkey
+
+```ts
+import { isMemberRefkey } from "@alloy-js/core";
+
+
+function isMemberRefkey(value: unknown): value is MemberRefkey;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| value | unknown |   |
+
+## Returns
+
+value is [MemberRefkey](../../types/memberrefkey/)

package/docs/api/functions/isNamekey.md

@@ -0,0 +1,18 @@
+# isNamekey
+
+```ts
+import { isNamekey } from "@alloy-js/core";
+
+
+function isNamekey(value: unknown): value is Namekey;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| value | unknown |   |
+
+## Returns
+
+value is [Namekey](../../types/namekey/)

package/docs/api/functions/isPrintHook.md

@@ -0,0 +1,18 @@
+# isPrintHook
+
+```ts
+import { isPrintHook } from "@alloy-js/core";
+
+
+function isPrintHook(type: unknown): type is PrintHook;
+```
+
+## Parameters
+
+|      |         |   |
+| ---- | ------- | - |
+| type | unknown |   |
+
+## Returns
+
+type is [PrintHook](../../types/printhook/)

package/docs/api/functions/isRefkey.md

@@ -0,0 +1,18 @@
+# isRefkey
+
+```ts
+import { isRefkey } from "@alloy-js/core";
+
+
+function isRefkey(value: unknown): value is Refkey;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| value | unknown |   |
+
+## Returns
+
+value is [Refkey](../../types/refkey/)

package/docs/api/functions/isRefkeyable.md

@@ -0,0 +1,18 @@
+# isRefkeyable
+
+```ts
+import { isRefkeyable } from "@alloy-js/core";
+
+
+function isRefkeyable(value: unknown): value is RefkeyableObject;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| value | unknown |   |
+
+## Returns
+
+value is [RefkeyableObject](../../types/refkeyableobject/)

package/docs/api/functions/isRenderableObject.md

@@ -0,0 +1,20 @@
+# isRenderableObject
+
+Returns true if the item is a renderable object, meaning it has an `[ay.RENDERABLE]` method.
+
+```ts
+import { isRenderableObject } from "@alloy-js/core";
+
+
+function isRenderableObject(item: unknown): item is RenderableObject;
+```
+
+## Parameters
+
+|      |         |   |
+| ---- | ------- | - |
+| item | unknown |   |
+
+## Returns
+
+item is [RenderableObject](../../types/renderableobject/) True if the item is a renderable object.

package/docs/api/functions/isSymbolRefkey.md

@@ -0,0 +1,18 @@
+# isSymbolRefkey
+
+```ts
+import { isSymbolRefkey } from "@alloy-js/core";
+
+
+function isSymbolRefkey(value: unknown): value is SymbolRefkey;
+```
+
+## Parameters
+
+|       |         |   |
+| ----- | ------- | - |
+| value | unknown |   |
+
+## Returns
+
+value is [SymbolRefkey](../../types/symbolrefkey/)

package/docs/api/functions/join.md

@@ -0,0 +1,33 @@
+# join
+
+Place a joiner between each element of an array or iterator. Defaults to joining with a newline.
+
+```ts
+import { join } from "@alloy-js/core";
+
+
+function join<T extends Children>(src: T[] | Iterator<T>, options?: JoinOptions): Children;
+```
+
+## Parameters
+
+|         |                      |   |
+| ------- | -------------------- | - |
+| src     | T\[] \| Iterator\<T> |   |
+| options | optional JoinOptions |   |
+
+## Options
+
+|           |                                            |                                                                                                                                                                                           |
+| --------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ender     | optional [Children](../../types/children/) | When true, the joiner is placed at the end of the array. When a string, that string is placed at the end of the array. The ender is only emitted when the array has at least one element. |
+| joiner    | optional [Children](../../types/children/) | The string to place between each element.                                                                                                                                                 |
+| skipFalsy | optional boolean                           | When true, falsy values with the exception of 0 are skipped.                                                                                                                              |
+
+## Returns
+
+[Children](../../types/children/) The joined array
+
+## See also
+
+* mapJoin for mapping before joining.

package/docs/api/functions/mapJoin.md

@@ -0,0 +1,106 @@
+# mapJoin
+
+## Overload 1
+
+Map a Map to an array using a mapper and place a joiner between each element. Defaults to joining with a newline.
+
+```ts
+import { mapJoin } from "@alloy-js/core";
+
+
+function mapJoin<T, U, V>(src: () => Map<T, U>, cb: (key: T, value: U, index: number) => V, options?: JoinOptions): () => (V | string | undefined | CustomContext)[];
+```
+
+### Parameters
+
+|         |                                        |   |
+| ------- | -------------------------------------- | - |
+| src     | () => Map\<T, U>                       |   |
+| cb      | (key: T, value: U, index: number) => V |   |
+| options | optional JoinOptions                   |   |
+
+### Options
+
+|           |                                            |                                                                                                                                                                                           |
+| --------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ender     | optional [Children](../../types/children/) | When true, the joiner is placed at the end of the array. When a string, that string is placed at the end of the array. The ender is only emitted when the array has at least one element. |
+| joiner    | optional [Children](../../types/children/) | The string to place between each element.                                                                                                                                                 |
+| skipFalsy | optional boolean                           | When true, falsy values with the exception of 0 are skipped.                                                                                                                              |
+
+### Returns
+
+() => (V | string | undefined | [CustomContext](../../types/customcontext/))\[] The mapped and joined array.
+
+### See also
+
+* [join](../join/) for joining without mapping.
+
+## Overload 2
+
+Map a Map to an array using a mapper and place a joiner between each element. Defaults to joining with a newline.
+
+```ts
+import { mapJoin } from "@alloy-js/core";
+
+
+function mapJoin<U, V>(src: () => Set<U>, cb: (value: U, index: number) => V, options?: JoinOptions): () => (V | string | undefined | CustomContext)[];
+```
+
+### Parameters
+
+|         |                                |   |
+| ------- | ------------------------------ | - |
+| src     | () => Set\<U>                  |   |
+| cb      | (value: U, index: number) => V |   |
+| options | optional JoinOptions           |   |
+
+### Options
+
+|           |                                            |                                                                                                                                                                                           |
+| --------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ender     | optional [Children](../../types/children/) | When true, the joiner is placed at the end of the array. When a string, that string is placed at the end of the array. The ender is only emitted when the array has at least one element. |
+| joiner    | optional [Children](../../types/children/) | The string to place between each element.                                                                                                                                                 |
+| skipFalsy | optional boolean                           | When true, falsy values with the exception of 0 are skipped.                                                                                                                              |
+
+### Returns
+
+() => (V | string | undefined | [CustomContext](../../types/customcontext/))\[] The mapped and joined array.
+
+### See also
+
+* [join](../join/) for joining without mapping.
+
+## Overload 3
+
+Map a array or iterator to another array using a mapper and place a joiner between each element. Defaults to joining with a newline.
+
+```ts
+import { mapJoin } from "@alloy-js/core";
+
+
+function mapJoin<T, V>(src: () => T[] | IterableIterator<T>, cb: (value: T, index: number) => V, options?: JoinOptions): () => (V | string | undefined | CustomContext)[];
+```
+
+### Parameters
+
+|         |                                    |   |
+| ------- | ---------------------------------- | - |
+| src     | () => T\[] \| IterableIterator\<T> |   |
+| cb      | (value: T, index: number) => V     |   |
+| options | optional JoinOptions               |   |
+
+### Options
+
+|           |                                            |                                                                                                                                                                                           |
+| --------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ender     | optional [Children](../../types/children/) | When true, the joiner is placed at the end of the array. When a string, that string is placed at the end of the array. The ender is only emitted when the array has at least one element. |
+| joiner    | optional [Children](../../types/children/) | The string to place between each element.                                                                                                                                                 |
+| skipFalsy | optional boolean                           | When true, falsy values with the exception of 0 are skipped.                                                                                                                              |
+
+### Returns
+
+() => (V | string | undefined | [CustomContext](../../types/customcontext/))\[] The mapped and joined array.
+
+### See also
+
+* [join](../join/) for joining without mapping.