@longform/async 0.2.0 → 0.2.1

package/dist/api-metadata.json

@@ -0,0 +1,1202 @@
+{
+  "metadata": {
+    "toolPackage": "@microsoft/api-extractor",
+    "toolVersion": "7.58.10",
+    "schemaVersion": 1011,
+    "oldestForwardsCompatibleVersion": 1001,
+    "tsdocConfig": {
+      "$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+      "noStandardTags": true,
+      "tagDefinitions": [
+        {
+          "tagName": "@alpha",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@beta",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@defaultValue",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@decorator",
+          "syntaxKind": "block",
+          "allowMultiple": true
+        },
+        {
+          "tagName": "@deprecated",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@eventProperty",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@example",
+          "syntaxKind": "block",
+          "allowMultiple": true
+        },
+        {
+          "tagName": "@experimental",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@inheritDoc",
+          "syntaxKind": "inline"
+        },
+        {
+          "tagName": "@internal",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@label",
+          "syntaxKind": "inline"
+        },
+        {
+          "tagName": "@link",
+          "syntaxKind": "inline",
+          "allowMultiple": true
+        },
+        {
+          "tagName": "@override",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@packageDocumentation",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@param",
+          "syntaxKind": "block",
+          "allowMultiple": true
+        },
+        {
+          "tagName": "@privateRemarks",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@public",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@readonly",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@remarks",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@returns",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@sealed",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@see",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@throws",
+          "syntaxKind": "block",
+          "allowMultiple": true
+        },
+        {
+          "tagName": "@typeParam",
+          "syntaxKind": "block",
+          "allowMultiple": true
+        },
+        {
+          "tagName": "@virtual",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@jsx",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@jsxRuntime",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@jsxFrag",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@jsxImportSource",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@betaDocumentation",
+          "syntaxKind": "modifier"
+        },
+        {
+          "tagName": "@internalRemarks",
+          "syntaxKind": "block"
+        },
+        {
+          "tagName": "@preapproved",
+          "syntaxKind": "modifier"
+        }
+      ],
+      "supportForTags": {
+        "@alpha": true,
+        "@beta": true,
+        "@defaultValue": true,
+        "@decorator": true,
+        "@deprecated": true,
+        "@eventProperty": true,
+        "@example": true,
+        "@experimental": true,
+        "@inheritDoc": true,
+        "@internal": true,
+        "@label": true,
+        "@link": true,
+        "@override": true,
+        "@packageDocumentation": true,
+        "@param": true,
+        "@privateRemarks": true,
+        "@public": true,
+        "@readonly": true,
+        "@remarks": true,
+        "@returns": true,
+        "@sealed": true,
+        "@see": true,
+        "@throws": true,
+        "@typeParam": true,
+        "@virtual": true,
+        "@betaDocumentation": true,
+        "@internalRemarks": true,
+        "@preapproved": true
+      },
+      "reportUnsupportedHtmlElements": false
+    }
+  },
+  "kind": "Package",
+  "canonicalReference": "@longform/async!",
+  "docComment": "",
+  "name": "@longform/async",
+  "preserveMemberOrder": false,
+  "members": [
+    {
+      "kind": "EntryPoint",
+      "canonicalReference": "@longform/async!",
+      "name": "",
+      "preserveMemberOrder": false,
+      "members": [
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!Annotation:type",
+          "docComment": "/**\n * The annotation method sets how data attributes can be set on elements outputted by the Longform parser. This is used by clients when searching the DOM for server rendered fragments, or in editing situations.\n *\n * `predictable` should only be used in situations where untrusted user data is not being added to the response. All data attributes would be prefixed with the `data-lf-` prefix, unless a `key` is passed in via the parser args.\n *\n * The predictable mode does not annotate fragments using data attributes if they have a Longform identifier as their HTML id.\n *\n * `obscure` creates a key that is hard to guess in advance when the document is created on the server. This should work in situations where HTTP caching is involved if the full document is created in one pass before being cached, as any untrusted data would also be baked into the response at the time of the obscure key's generation.\n *\n * This approach to obscuring potential data-attribute conflicts is not fool proof. Do not use it in situations where part of a Longform document would be parsed and cached before passing into another document which includes untrusted user data. The first pass might cache the obscure key and allow users to mimic the response and define blocks of HTML that are picked by the client's DOM processing logic.\n *\n * @see\n *\n * [Longform's security considerations](https://longform.occultist.dev/#security-considerations)\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type Annotation = "
+            },
+            {
+              "kind": "Content",
+              "text": "'none' | 'predictable' | 'obscure'"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "Annotation",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!AsyncRenderCtx:type",
+          "docComment": "/**\n * Context supplied to async directives.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type AsyncRenderCtx = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    inlineArgs?: string;\n    blockArgs?: string;\n    doc: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Readonly",
+              "canonicalReference": "!Readonly:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "Doc",
+              "canonicalReference": "@longform/async!Doc:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "AsyncRenderCtx",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 6
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!AttrCtx:type",
+          "docComment": "/**\n * Context supplied to attr directives\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type AttrCtx = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    tag: string;\n    doc: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Readonly",
+              "canonicalReference": "!Readonly:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "Doc",
+              "canonicalReference": "@longform/async!Doc:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "AttrCtx",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 6
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!Directive:type",
+          "docComment": "/**\n * Directive definition object. Directives can support multiple roles but some crate ambiguities and should not be used together. The parser will ignore the directive if it implements hooks for conflicting roles.\n *\n * A directive implementing `meta` cannot implement `element`. A directive implementing `element` cannot implement `render` or `asyncRender`. A directive implementing `render` cannot implement `asyncRender`.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type Directive = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    meta?: (args: "
+            },
+            {
+              "kind": "Reference",
+              "text": "MetaCtx",
+              "canonicalReference": "@longform/async!MetaCtx:type"
+            },
+            {
+              "kind": "Content",
+              "text": ") => unknown;\n    global?: (ctx: "
+            },
+            {
+              "kind": "Reference",
+              "text": "GlobalCtx",
+              "canonicalReference": "@longform/async!GlobalCtx:type"
+            },
+            {
+              "kind": "Content",
+              "text": ") => void;\n    attr?: (ctx: "
+            },
+            {
+              "kind": "Reference",
+              "text": "AttrCtx",
+              "canonicalReference": "@longform/async!AttrCtx:type"
+            },
+            {
+              "kind": "Content",
+              "text": ") => string | boolean | undefined | null;\n    element?: (ctx: "
+            },
+            {
+              "kind": "Reference",
+              "text": "ElementCtx",
+              "canonicalReference": "@longform/async!ElementCtx:type"
+            },
+            {
+              "kind": "Content",
+              "text": ") => void;\n    render?: (ctx: "
+            },
+            {
+              "kind": "Reference",
+              "text": "RenderCtx",
+              "canonicalReference": "@longform/async!RenderCtx:type"
+            },
+            {
+              "kind": "Content",
+              "text": ") => string | undefined;\n    asyncRender?: (ctx: "
+            },
+            {
+              "kind": "Reference",
+              "text": "AsyncRenderCtx",
+              "canonicalReference": "@longform/async!AsyncRenderCtx:type"
+            },
+            {
+              "kind": "Content",
+              "text": ") => string | undefined | "
+            },
+            {
+              "kind": "Reference",
+              "text": "Promise",
+              "canonicalReference": "!Promise:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<string | undefined>;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "Directive",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 16
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!Doc:type",
+          "docComment": "/**\n * A doc object used to provide directives with meta information about the doc while it is being parsed.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type Doc = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    id?: string;\n    type?: string;\n    lang?: string;\n    dir?: string;\n    meta: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Readonly",
+              "canonicalReference": "!Readonly:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, unknown>>;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "Doc",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 6
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!Element_2:type",
+          "docComment": "/**\n * An element's description. Directives with access to elements should only apply changes to its `attrs` object. The `id` can be set via the `attrs` object if it does not already have a value, and classes can be appended to the `class` value via the `attrs` object.\n *\n * The element's tag cannot be changed.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type Element = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    tag: string;\n    id?: string;\n    class?: string;\n    attrs: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, boolean | string>;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "Element_2",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!ElementCtx:type",
+          "docComment": "/**\n * Context supplied to element directives.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type ElementCtx = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    inlineArgs?: string;\n    blockArgs?: string;\n    doc: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Readonly",
+              "canonicalReference": "!Readonly:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "Doc",
+              "canonicalReference": "@longform/async!Doc:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n    el: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Element",
+              "canonicalReference": "@longform/async!Element_2:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    chain: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Element",
+              "canonicalReference": "@longform/async!Element_2:type"
+            },
+            {
+              "kind": "Content",
+              "text": "[];\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "ElementCtx",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 10
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!Fragment:type",
+          "docComment": "/**\n * A fragment object.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type Fragment = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    id: string;\n    selector: string;\n    type: "
+            },
+            {
+              "kind": "Reference",
+              "text": "FragmentType",
+              "canonicalReference": "@longform/async!FragmentType:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    html: string;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "Fragment",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!FragmentType:type",
+          "docComment": "/**\n * The fragment type.\n *\n * `embed` indicates the fragment has a unique embedded HTML id. `bare` indicates the fragment has no embedded HTML id. `range` indicates the fragment is a range of elements, instead of having a single top level element. `text` indicates the fragment is text only can can be used in situations where HTML might be invalid.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type FragmentType = "
+            },
+            {
+              "kind": "Content",
+              "text": "'embed' | 'bare' | 'range' | 'text'"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "FragmentType",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!GlobalCtx:type",
+          "docComment": "/**\n * Context supplied to directives declared in the global directive.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type GlobalCtx = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    doc: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Doc",
+              "canonicalReference": "@longform/async!Doc:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "GlobalCtx",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@longform/async!longform:function(1)",
+          "docComment": "/**\n * Parses a longform document into a object containing the root and fragments in the output format.\n *\n * @param input - The Longform document to parse.\n *\n * @param args - Arguments for the Longform parser.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function longform(input: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ", args?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "LongformArgs",
+              "canonicalReference": "@longform/async!LongformArgs:type"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Reference",
+              "text": "Promise",
+              "canonicalReference": "!Promise:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "ParsedLongform",
+              "canonicalReference": "@longform/async!ParsedLongform:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/longform.d.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 5,
+            "endIndex": 9
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "input",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "args",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "isOptional": true
+            }
+          ],
+          "name": "longform"
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!LongformArgs:type",
+          "docComment": "/**\n * The Longform parser is designed to serve multiple roles.\n *\n * In a situation where a document containing a HTML page's main content is split from a re-useable layout the `'doc'` output mode can be used on the main content and the result passed as arguments to the Longform parser when parsing the layout document. The id, type, lang and direction as well as any custom meta values and the parsed fragments from the main document will be available to the template's fragments.\n *\n * In a situation where a directive is being defined, the output mode `head` can be used to use the Longform parser as a DSL for custom directives. The `templates` output mode can be used to parse the block arguments of the directive as Longform templates, with the directive supplying arguments specified by the directive.\n *\n * The `mountable` output mode is used where Longform needs to be outputted so another libraries SSR rendered content can fill the gaps in mountable elements. Usually this would be used for a layout document which is used in a similar way to Astro's islands.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type LongformArgs = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    key?: string;\n    id?: string;\n    type?: string;\n    lang?: string;\n    dir?: string;\n    meta?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, unknown>;\n    targetType?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "TargetType",
+              "canonicalReference": "@longform/async!TargetType:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    outputMode?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "OutputMode",
+              "canonicalReference": "@longform/async!OutputMode:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    annotations?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Annotation",
+              "canonicalReference": "@longform/async!Annotation:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    directives?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, "
+            },
+            {
+              "kind": "Reference",
+              "text": "Directive",
+              "canonicalReference": "@longform/async!Directive:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n    fragments?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, "
+            },
+            {
+              "kind": "Reference",
+              "text": "Fragment",
+              "canonicalReference": "@longform/async!Fragment:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "LongformArgs",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 18
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!MetaCtx:type",
+          "docComment": "/**\n * Context supplied to meta directives.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type MetaCtx = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    inlineArgs?: string;\n    blockArgs?: string;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "MetaCtx",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!MountPoint:type",
+          "docComment": "/**\n * If the parser's output mode is `mountable`, the Longform parser will break output of the root element up in locations where the `@mount:: mountPointId` directive is used.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type MountPoint = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    id: string;\n    part: string;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "MountPoint",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!OutputMode:type",
+          "docComment": "/**\n * The Longform parser supports several output modes which are useful for different situations.\n *\n * `doc` Outputs all fragments normally.\n *\n * `head` Parses the `\\@id`, `\\@type`, `\\@lang`, `\\@dir` and any directives implementing the `meta` directive hook. It exits as soon as it hits another directive type or fragment declaration.\n *\n * `mountable` Supports use of the `\\@mount` directive for turning elements into mountpoints. This output mode populates the `mountpoints` array in the parse result. This array can be looped over and data from another rendering tool can mount its output into the named mount points. Once all mountpoint entries have been populated the `tail` property in the parsed result should be appended to the final document.\n *\n * The mountable mode is currently very basic in implementation and only supports documents implementing a single root element.\n *\n * `templates` parses every fragment as though it was a template even if the `\\@template` directive is not used. This is useful for creating directives which use the block args to define a Longform template.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type OutputMode = "
+            },
+            {
+              "kind": "Content",
+              "text": "'doc' | 'head' | 'mountable' | 'templates'"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "OutputMode",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!ParsedLongform:type",
+          "docComment": "/**\n * An object containing the parsed Longform result.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type ParsedLongform = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    key?: string;\n    id?: string;\n    type?: string;\n    lang?: string;\n    dir?: string;\n    meta: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, unknown>;\n    targetType?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "TargetType",
+              "canonicalReference": "@longform/async!TargetType:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    outputMode: "
+            },
+            {
+              "kind": "Reference",
+              "text": "OutputMode",
+              "canonicalReference": "@longform/async!OutputMode:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    annotations?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Annotation",
+              "canonicalReference": "@longform/async!Annotation:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    root?: string;\n    template?: string;\n    selector?: string;\n    fragments: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, "
+            },
+            {
+              "kind": "Reference",
+              "text": "Fragment",
+              "canonicalReference": "@longform/async!Fragment:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n    templates: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, string>;\n    mountpoints?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "MountPoint",
+              "canonicalReference": "@longform/async!MountPoint:type"
+            },
+            {
+              "kind": "Content",
+              "text": "[];\n    tail?: string;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "ParsedLongform",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 18
+          }
+        },
+        {
+          "kind": "Function",
+          "canonicalReference": "@longform/async!processTemplate:function(1)",
+          "docComment": "/**\n * Processes a client side Longform template to HTML fragment string.\n *\n * @param fragment - The fragment template.\n *\n * @param args - Args for the template.\n *\n * @param longformArgs - Args for the Longform parser.\n *\n * @param getFragment - A function which returns an already processed fragment's HTML string.\n *\n * @returns The processed template.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function processTemplate(template: "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ", args: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Record",
+              "canonicalReference": "!Record:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<string, string | number>"
+            },
+            {
+              "kind": "Content",
+              "text": ", longformArgs?: "
+            },
+            {
+              "kind": "Reference",
+              "text": "LongformArgs",
+              "canonicalReference": "@longform/async!LongformArgs:type"
+            },
+            {
+              "kind": "Content",
+              "text": ", getFragment?: "
+            },
+            {
+              "kind": "Content",
+              "text": "(fragment: string) => string | undefined"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Reference",
+              "text": "Promise",
+              "canonicalReference": "!Promise:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "TemplateOutput",
+              "canonicalReference": "@longform/async!TemplateOutput:type"
+            },
+            {
+              "kind": "Content",
+              "text": " | undefined>"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/longform.d.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 10,
+            "endIndex": 14
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "template",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "args",
+              "parameterTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 5
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "longformArgs",
+              "parameterTypeTokenRange": {
+                "startIndex": 6,
+                "endIndex": 7
+              },
+              "isOptional": true
+            },
+            {
+              "parameterName": "getFragment",
+              "parameterTypeTokenRange": {
+                "startIndex": 8,
+                "endIndex": 9
+              },
+              "isOptional": true
+            }
+          ],
+          "name": "processTemplate"
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!RenderCtx:type",
+          "docComment": "/**\n * Context supplied to render directives.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type RenderCtx = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    inlineArgs?: string;\n    blockArgs?: string;\n    doc: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Readonly",
+              "canonicalReference": "!Readonly:type"
+            },
+            {
+              "kind": "Content",
+              "text": "<"
+            },
+            {
+              "kind": "Reference",
+              "text": "Doc",
+              "canonicalReference": "@longform/async!Doc:type"
+            },
+            {
+              "kind": "Content",
+              "text": ">;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "RenderCtx",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 6
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!TargetType:type",
+          "docComment": "/**\n * The content type of the response can be passed into the Longform parser to change the shape of the output. The default value `text/html` will use HTML's method for closing void tags. The XML versions would use XML valid syntax.\n *\n * If `application/xml` is provided, no data attributes will be added to the outputted markup, even if an annotation mode or key is given.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type TargetType = "
+            },
+            {
+              "kind": "Content",
+              "text": "'text/html' | 'application/xhtml+xml' | 'application/xml'"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "TargetType",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 2
+          }
+        },
+        {
+          "kind": "TypeAlias",
+          "canonicalReference": "@longform/async!TemplateOutput:type",
+          "docComment": "/**\n * An object containing a parsed Longform template.\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export type TemplateOutput = "
+            },
+            {
+              "kind": "Content",
+              "text": "{\n    id?: string;\n    type: 'root' | "
+            },
+            {
+              "kind": "Reference",
+              "text": "FragmentType",
+              "canonicalReference": "@longform/async!FragmentType:type"
+            },
+            {
+              "kind": "Content",
+              "text": ";\n    html: string;\n}"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "dist/types_temp/types.d.ts",
+          "releaseTag": "Public",
+          "name": "TemplateOutput",
+          "typeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        }
+      ]
+    }
+  ]
+}