@format.dev/react 0.0.0 → 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,621 @@
+import * as react0 from "react";
+import { CSSProperties, ElementType, HTMLAttributes, PropsWithChildren, ReactNode } from "react";
+
+//#region src/types.d.ts
+
+/**
+ * How a Flow splits content that overflows a page: at a `sentence`, `word`, or
+ * `grapheme` boundary, or `none` to keep the block whole and move it to the next
+ * page intact. Use the constant (`SplitGranularity.None`) or the plain string
+ * (`'none'`); both are accepted.
+ */
+declare const SplitGranularity: {
+  readonly Sentence: "sentence";
+  readonly Word: "word";
+  readonly Grapheme: "grapheme";
+  readonly None: "none";
+};
+type SplitGranularity = (typeof SplitGranularity)[keyof typeof SplitGranularity];
+/**
+ * The dot leader between a contents entry's title and its page number. The default,
+ * `dots`, draws it; `none` leaves the run between them blank. Use the constant
+ * (`TocLeader.None`) or the plain string (`'none'`); both are accepted.
+ */
+declare const TocLeader: {
+  readonly Dots: "dots";
+  readonly None: "none";
+};
+type TocLeader = (typeof TocLeader)[keyof typeof TocLeader];
+/** How a Layout or Flow decides where pages break: `auto` on overflow
+ * and at PageBreak markers, `manual` at PageBreak markers only. */
+type PaginationStrategy = 'auto' | 'manual';
+/**
+ * How the PDF embeds its fonts. Mirrors `FontMode` in `@format.dev/fonts`, which owns
+ * the canonical list and the default.
+ */
+type FontMode = 'fidelity' | 'compact';
+/**
+ * A CSS `<counter-style>` name. The predefined styles autocomplete; any custom
+ * `@counter-style` name you define is accepted too.
+ */
+type CounterStyle = 'decimal' | 'decimal-leading-zero' | 'lower-roman' | 'upper-roman' | 'lower-alpha' | 'upper-alpha' | 'lower-latin' | 'upper-latin' | 'lower-greek' | (string & {});
+//#endregion
+//#region src/Document.d.ts
+interface DocumentProps {
+  title: string;
+  subject?: string;
+  author?: string;
+  keywords?: string[];
+  /**
+   * How the PDF embeds its fonts — file size against rendering quality. Leave
+   * unset for most documents; set `'fidelity'` when exact text rendering
+   * matters more than file size.
+   *
+   * - Compact (the default) keeps files small: the fonts embed as subset CID
+   *   instances, so the optical size is fixed and strokes can look slightly
+   *   heavier in some viewers (for example macOS Preview).
+   * - Fidelity gives the best-looking output: text keeps its exact optical
+   *   sizing and renders at the same weight in every PDF viewer. The cost is a
+   *   larger file, since the fonts embed as Type 3.
+   */
+  fonts?: FontMode;
+}
+/**
+ * Props the Format runtime passes to a document entry function. The
+ * generic parameter is the shape of the active data variant.
+ *
+ * ```tsx
+ * import type { Invoice } from './types'
+ *
+ * export default function InvoiceDocument({ data }: RenderProps<Invoice>) {
+ *   return <Document title={`Invoice #${data.id}`}>{/* ... *\/}</Document>
+ * }
+ * ```
+ */
+interface RenderProps<T = unknown> {
+  data: T;
+}
+declare function Document({
+  title,
+  subject,
+  author,
+  keywords,
+  fonts,
+  children
+}: PropsWithChildren<DocumentProps>): react0.JSX.Element;
+//#endregion
+//#region src/Layout.d.ts
+interface LayoutProps {
+  /** Design label, mirrored to each page as `data-layout-id` for CSS. Optional:
+   * when omitted, the engine generates one from the Layout's document position. */
+  id?: string;
+  width: number;
+  height: number;
+  paginationStrategy?: PaginationStrategy;
+  splitGranularity?: SplitGranularity;
+}
+declare function Layout({
+  id,
+  width,
+  height,
+  paginationStrategy,
+  splitGranularity,
+  children
+}: PropsWithChildren<LayoutProps>): react0.JSX.Element;
+//#endregion
+//#region src/Flow.d.ts
+interface FlowProps {
+  /** How content breaks when it doesn't fit the current page. When unset, it
+   * inherits from the enclosing Flow, then the Layout, then defaults to `none`. */
+  splitGranularity?: SplitGranularity;
+  /** Whether this Flow paginates on overflow (`auto`) or only at PageBreak
+   * markers (`manual`). Inherits the owning Layout's strategy when unset. */
+  paginationStrategy?: PaginationStrategy;
+  /** Opens a numbering scope of this counter name around the Flow's content, so
+   * a counter nested inside restarts per Flow instance (e.g. `1.1`, `1.2`). */
+  scope?: string;
+}
+/**
+ * A Flow is a region whose content paginates across pages. Everything inside the
+ * Flow that isn't its Stream is scaffolding that repeats on every page the
+ * content spans; the stream's items appear once and flow.
+ *
+ * Author the stream two ways:
+ *
+ * - **bare** — `<Flow>{items}</Flow>`: the Flow's own children are the stream,
+ *   injected with no wrapper element.
+ * - **scaffolded** — wrap the stream in a `<Stream>` inside surrounding markup,
+ *   e.g. `<Flow><table><thead/><Stream>{rows}</Stream><tfoot/></table></Flow>`:
+ *   the table, thead, and tfoot repeat per page; the rows flow.
+ *
+ * Flows nest: a Flow placed inside another Flow's stream paginates against the
+ * nearest enclosing sealing region (a Frame, else the page), re-cloning its own
+ * scaffolding on each page its content reaches.
+ */
+declare function Flow({
+  splitGranularity,
+  paginationStrategy,
+  scope,
+  children
+}: PropsWithChildren<FlowProps>): react0.JSX.Element;
+//#endregion
+//#region src/Stream.d.ts
+/**
+ * A Stream marks where a scaffolded Flow's items land. Use it when a Flow wraps
+ * its content in repeating scaffolding (a table's header and footer, a titled
+ * panel) and you need to say where in that scaffolding the stream flows in:
+ *
+ * ```tsx
+ * <Flow>
+ *   <table>
+ *     <thead>…</thead>
+ *     <Stream>{rows}</Stream>
+ *     <tfoot>…</tfoot>
+ *   </table>
+ * </Flow>
+ * ```
+ *
+ * Omit it for a bare Flow, where the Flow's own children are the stream.
+ */
+declare function Stream({
+  children
+}: PropsWithChildren): react0.JSX.Element;
+//#endregion
+//#region src/PageBreak.d.ts
+declare function PageBreak(): react0.JSX.Element;
+//#endregion
+//#region src/PageCounter.d.ts
+interface PageCounterBaseProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+  /**
+   * HTML tag to render. Defaults to `span`. Use `div` (or another block-level
+   * element) when the counter needs its own line.
+   */
+  as?: ElementType;
+  /**
+   * CSS `<counter-style>` used to format the counter — e.g. `decimal`,
+   * `lower-roman`, `upper-alpha`, or a custom `@counter-style` name. Sets
+   * `--page-counter-style` inline; defaults to `decimal` from the base
+   * stylesheet when omitted.
+   */
+  counterStyle?: CounterStyle;
+}
+//#endregion
+//#region src/PageNumber.d.ts
+type PageNumberProps = PageCounterBaseProps;
+declare function PageNumber(props: PageNumberProps): react0.JSX.Element;
+//#endregion
+//#region src/PageCount.d.ts
+type PageCountProps = PageCounterBaseProps;
+declare function PageCount(props: PageCountProps): react0.JSX.Element;
+//#endregion
+//#region src/Counter.d.ts
+interface CounterBase extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+  /**
+   * The counter to read or advance. Counters are created on first use, so any
+   * name works — `figure`, `table`, `step`. The same name shares one running
+   * value across the whole document.
+   */
+  name: string;
+  /**
+   * Read the current value without advancing it. Use this to refer back to a
+   * number you already showed, e.g. "see Figure <Counter name='figure' peek />".
+   */
+  peek?: boolean;
+  /**
+   * Reset the counter to 0 at this point and render nothing — the start of a
+   * fresh run (a new chapter restarting its figures).
+   */
+  reset?: boolean;
+  /**
+   * Join the whole nested chain of this counter with the given separator — the
+   * `counters()` read, for nested lists: `join="."` shows `1.2.1`. Without it,
+   * only the innermost value is shown.
+   */
+  join?: string;
+  /**
+   * HTML tag to render. Defaults to `span`.
+   */
+  as?: ElementType;
+  /**
+   * CSS `<counter-style>` used to format the value — e.g. `decimal`,
+   * `lower-roman`, `upper-alpha`. Defaults to `decimal`.
+   */
+  counterStyle?: CounterStyle;
+}
+/**
+ * `set` and `by` are mutually exclusive: `set` jumps to an exact value, `by`
+ * advances. Passing both is a contradiction the type rejects.
+ */
+type CounterProps = CounterBase & ({
+  set?: undefined;
+  /** How much to advance by before showing the value. Defaults to 1. */
+  by?: number;
+} | {
+  /** Set the counter to an exact value and show it. */
+  set: number;
+  by?: undefined;
+});
+/**
+ * A counter whose value survives pagination. Unlike a CSS counter, which resets
+ * on every page, this is resolved by Format before pages are split, so the
+ * number stays correct wherever the content lands.
+ *
+ * By default it advances the counter and shows the new value — the usual "this
+ * is Figure N" case. `peek` reads without advancing, `set` jumps to a value, and
+ * `reset` starts the count over. These three are mutually exclusive; when more
+ * than one is set, `reset` wins, then `set`, then `peek`. `by` applies only to
+ * the default advance.
+ *
+ * Give the counter an `id` to make it referenceable. A `<Ref to="that-id" />`
+ * then prints the exact value this counter showed, and `<Ref to="that-id" page />`
+ * the page it landed on — the same way a heading's id yields its section number.
+ */
+declare function Counter({
+  name,
+  peek,
+  reset,
+  set,
+  by,
+  join,
+  as: Tag,
+  counterStyle,
+  ...rest
+}: CounterProps): react0.JSX.Element;
+//#endregion
+//#region src/Numbering.d.ts
+interface NumberingRuleBase {
+  /**
+   * CSS selector for the elements this rule numbers, e.g. `h2`, `figure figcaption`,
+   * `.step`. Every match advances the counter in document order.
+   */
+  match: string;
+  /**
+   * The counter this rule advances. Defaults to the selector, so a single-tag
+   * rule needs no separate name.
+   */
+  counter?: string;
+  /**
+   * The text inserted into each match, with `{counter}` placeholders. For
+   * example `Figure {figure}: ` or `{chapter:upper-roman}. `. A placeholder may
+   * carry its own style after a colon. When omitted, the rule advances the
+   * counter but inserts nothing — pair it with a <Counter> read.
+   */
+  format?: string;
+  /**
+   * Default `<counter-style>` for placeholders in `format`. Defaults to `decimal`.
+   */
+  counterStyle?: CounterStyle;
+  /**
+   * Where the formatted number goes relative to the matched element:
+   * `before` its content (the default), `after` it, or `none` to only keep the
+   * counter running. To restart a counter under another, declare it with
+   * `<CounterDef resetEach>`; to nest a counter, mark the container `data-scope`.
+   */
+  insert?: 'before' | 'after' | 'none';
+}
+/**
+ * `set` and `increment` are mutually exclusive: `set` forces an exact value on
+ * each match, `increment` advances. Passing both is a contradiction the type
+ * rejects.
+ */
+type NumberingRuleProps = NumberingRuleBase & ({
+  set?: undefined;
+  /**
+   * How much to advance the counter on each match. Defaults to 1. Set to `0` when a
+   * rule should not advance a counter of its own, e.g. a rule whose only job is to
+   * reset another counter (a nested-list rule that opens a fresh scope for the
+   * counter you read).
+   */
+  increment?: number;
+} | {
+  /** Set the counter to this exact value on each match instead of advancing it. */
+  set: number;
+  increment?: undefined;
+});
+interface NumberingProps {
+  /**
+   * The default counter style for every counter the document numbers. Per-rule,
+   * per-Counter, and per-Footnotes styles override it. Defaults to `decimal`.
+   */
+  counterStyle?: CounterStyle;
+}
+/**
+ * Turns on document-wide numbering. With no children it numbers headings `h1`
+ * through `h6` hierarchically — `1`, `1.1`, `1.1.1` — with each level resetting
+ * the ones beneath it. Add <NumberingRule> children to number other things or
+ * change the format.
+ *
+ * Numbers are resolved before pages are split, so they stay correct across page
+ * breaks where plain CSS counters would reset.
+ *
+ * ```tsx
+ * <Document title="Report">
+ *   <Numbering />
+ *   ...
+ * </Document>
+ * ```
+ */
+declare function Numbering({
+  counterStyle,
+  children
+}: PropsWithChildren<NumberingProps>): react0.JSX.Element;
+/**
+ * One numbering rule, used as `<NumberingRule>` inside `<Numbering>`. Each rule
+ * matches a selector and advances (and optionally inserts) a counter. Add rules
+ * to number things beyond the default headings, or to change the heading format.
+ */
+declare function NumberingRule({
+  match,
+  counter,
+  format,
+  increment,
+  set,
+  counterStyle,
+  insert
+}: NumberingRuleProps): react0.JSX.Element;
+interface CounterDefProps {
+  /** The counter this defines. Shared by name across the document. */
+  name: string;
+  /**
+   * The counter this one restarts under, if any: whenever that owner advances, this
+   * counter returns to 0. A `figure` set to restart under `chapter` reads "Figure 2.1".
+   * The restart cascades, so a new chapter zeros section and, under section, figure.
+   */
+  resetEach?: string;
+}
+/**
+ * Declares one counter's behaviour, used as `<CounterDef>` inside `<Numbering>`. Name
+ * the counter and, optionally, the owner counter it restarts under. A counter with an
+ * owner returns to 0 every time the owner's value changes; one with no owner restarts
+ * only when you reset or set it yourself.
+ *
+ * ```tsx
+ * <Numbering>
+ *   <CounterDef name="figure" resetEach="chapter" />
+ *   <NumberingRule match="figcaption" counter="figure" format="Figure {chapter}.{figure}: " />
+ * </Numbering>
+ * ```
+ */
+declare function CounterDef({
+  name,
+  resetEach
+}: CounterDefProps): react0.JSX.Element;
+//#endregion
+//#region src/Scope.d.ts
+interface ScopeProps {
+  /**
+   * The counter to open a fresh nested instance for across this wrapper's content — a
+   * level of a nested list. Pass several space-separated to scope more than one. A
+   * `<Counter join>` inside reads the whole open stack.
+   */
+  counter: string;
+}
+/**
+ * Opens a counter scope around its children and adds no element to the output: a
+ * `<Scope>` is the fallback for nesting content that has no element of its own to carry
+ * the scope. When the content already sits in a container or a `<Flow>`, mark that
+ * directly (`<ol data-scope="item">`, `<Flow scope="item">`) instead of wrapping.
+ *
+ * ```tsx
+ * <Scope counter="item">
+ *   <Counter name="item" join="." /> First
+ *   <Scope counter="item">
+ *     <Counter name="item" join="." /> Nested
+ *   </Scope>
+ * </Scope>
+ * ```
+ */
+declare function Scope({
+  counter,
+  children
+}: PropsWithChildren<ScopeProps>): react0.JSX.Element;
+//#endregion
+//#region src/Ref.d.ts
+interface RefProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+  /**
+   * The `id` to point at. Put an id on a heading to reference its section number,
+   * or on a `<Counter>` to reference the value that counter printed. The target
+   * can appear anywhere in the document, before or after this reference.
+   */
+  to: string;
+  /**
+   * Read a named counter's value as it stood at the target, e.g. `counter="figure"`
+   * for the figure count at that point in the document. Omit it to show the
+   * target's own number — a heading's section number, or the value a
+   * `<Counter id="…">` printed.
+   */
+  counter?: string;
+  /**
+   * Show the page the target landed on, e.g. "see page 12". Resolved after
+   * pagination. Takes precedence over `counter`.
+   */
+  page?: boolean;
+  /**
+   * HTML tag to render. Defaults to `span`.
+   */
+  as?: ElementType;
+  /**
+   * CSS `<counter-style>` used to format the value. Defaults to `decimal`.
+   */
+  counterStyle?: CounterStyle;
+}
+/**
+ * A cross-reference to a numbered element — "see Section 2.1" or "Figure 3".
+ * Point it at an `id`: a heading's id yields its section number, a `<Counter>`'s
+ * id yields the value that counter printed. Add `page` for the page the target
+ * landed on, or `counter` to read a named counter's running value at the target.
+ *
+ * References resolve before pages are split and can point forward to an element
+ * that appears later in the document.
+ *
+ * ```tsx
+ * <figcaption>Figure <Counter name="figure" id="flow" />: the data flow</figcaption>
+ * // ...anywhere else in the document:
+ * <p>The method (see Section <Ref to="method" />) reads Figure <Ref to="flow" />,
+ *    shown in full on page <Ref to="flow" page />.</p>
+ * ```
+ */
+declare function Ref({
+  to,
+  counter,
+  page,
+  as: Tag,
+  counterStyle,
+  ...rest
+}: RefProps): react0.JSX.Element;
+//#endregion
+//#region src/TableOfContents.d.ts
+interface TableOfContentsProps {
+  /**
+   * CSS selector for the headings to list. Defaults to `h1, h2, h3`.
+   */
+  collect?: string;
+  /**
+   * The dot leader between each entry's title and its page number. The default,
+   * `dots`, draws it; `none` leaves the run between them blank.
+   */
+  leader?: TocLeader;
+  /**
+   * Repeat the leading content with the nav on every page the contents spans, like a
+   * running header. Off by default: the leading content shows once, above the entries.
+   */
+  repeatHead?: boolean;
+  /**
+   * Leading content rendered at the top of the contents, above the entries — a
+   * "Contents" heading, an intro line, a rule. Shown once by default; set `repeatHead`
+   * to repeat it with the nav on every page the contents spans.
+   */
+  children?: ReactNode;
+  /**
+   * A class on the rendered `<nav>`. Style the contents with your own CSS, or use
+   * `styled(TableOfContents)`.
+   */
+  className?: string;
+  /** An inline style on the rendered `<nav>`. */
+  style?: CSSProperties;
+}
+/**
+ * A table of contents. Format fills it after laying out the document: one entry
+ * per heading the `collect` selector matches, each with the heading's number, its
+ * title, and the page it landed on.
+ *
+ * The entries are flat anchors in a `<div data-type="toc-entries">` inside a
+ * `<nav data-type="toc">`: each is an `<a data-type="toc-entry" data-depth="N">`
+ * (depth 0 at the top of the outline) holding `toc-number`, `toc-title`, and
+ * `toc-page` spans. Depth is data, not nesting, so the stylesheet indents and sizes
+ * by depth and a long contents paginates by breaking between anchors. Style it through
+ * the `data-type` hooks and the `--toc-*` custom properties (root size, per-depth size
+ * and indent, page-number size, leader, and vertical rhythm), or set a `className` (or
+ * `styled(TableOfContents)`) on the nav. Set `leader="none"` to omit the dot leader
+ * entirely, so no leader is drawn between a title and its page number.
+ *
+ * Children are leading content shown above the entries — put a "Contents" heading there.
+ * It shows once by default; set `repeatHead` to repeat it with the nav on every page.
+ *
+ * Give a collected heading a `data-toc-description` and its entry gains a
+ * `toc-description` line under the title (a one-line summary, as on a magazine or
+ * report contents):
+ *
+ * ```tsx
+ * <TableOfContents collect="h1, h2">
+ *   <h2>Contents</h2>
+ * </TableOfContents>
+ *
+ * <h1 data-toc-description="Defining the studio's personality and direction.">
+ *   Visual Positioning
+ * </h1>
+ * ```
+ */
+declare function TableOfContents({
+  collect,
+  leader,
+  repeatHead,
+  className,
+  style,
+  children
+}: TableOfContentsProps): react0.JSX.Element;
+//#endregion
+//#region src/Footnote.d.ts
+/**
+ * A footnote. Write the note's text as the children, at the point it's
+ * referenced; Format leaves a numbered marker inline and moves the text to the
+ * footer of whichever page the marker lands on. Footnotes are numbered
+ * continuously through the document.
+ *
+ * Pair it with a `<Footnotes />` region in the Layout to control where the notes
+ * sit; without one, Format adds a footer area to each page that needs it.
+ *
+ * ```tsx
+ * <p>The result holds<Footnote>under the stated assumptions</Footnote>.</p>
+ * ```
+ */
+declare function Footnote({
+  children
+}: PropsWithChildren): react0.JSX.Element;
+//#endregion
+//#region src/Footnotes.d.ts
+interface FootnotesProps {
+  /**
+   * The counter style for the note numbers and their inline markers. Defaults to
+   * the document's numbering style, or `decimal`.
+   */
+  counterStyle?: CounterStyle;
+  /**
+   * Restart the numbering on each page, so every page's footer reads 1, 2, 3 rather
+   * than a count that runs the whole document. For a per-page footer in a Layout; the
+   * inline markers renumber to match. Off by default (continuous numbering).
+   */
+  restartEachPage?: boolean;
+  /**
+   * Whether the leading content (a heading, a rule) repeats in every page's footer. On by
+   * default for a per-page Layout footer; an inline endnotes block shows it once. Set `false`
+   * to show a Layout footer's head on its first page only.
+   */
+  repeatHead?: boolean;
+  /** A class name passed through to the wrapping footnotes container. */
+  className?: string;
+  /** An inline style passed through to the wrapping footnotes container. */
+  style?: CSSProperties;
+}
+/**
+ * The region that collects a page's footnotes, authored as a `<template>` Format
+ * fills. In a Layout it is a per-page footer gathering the notes whose markers
+ * landed there; in a flow's content it is an endnotes list. Format renders it as an
+ * `<aside data-type="footnotes">` holding a `<dl data-type="footnote-entries">`, where
+ * each note is a `<dt data-type="footnote-number">` term and a
+ * `<dd data-type="footnote-content">` definition; style the list as a grid with your
+ * own CSS.
+ *
+ * Put a heading or rule inside `<Footnotes>` to render it above the generated list,
+ * the way a table of contents renders its leading content above the entries:
+ *
+ * ```tsx
+ * <Footnotes>
+ *   <h4>Notes</h4>
+ * </Footnotes>
+ * ```
+ *
+ * Omit it and Format adds a plain footer to each page that has footnotes.
+ */
+declare function Footnotes({
+  counterStyle,
+  restartEachPage,
+  repeatHead,
+  className,
+  style,
+  children
+}: PropsWithChildren<FootnotesProps>): react0.JSX.Element;
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Tagged template for authoring CSS, typically inside a `<style>` element.
+ * Returns the string from the raw segments, so CSS escapes (`\2014`,
+ * icon-font codepoints, escaped selectors) survive intact. Interpolated
+ * `null`, `undefined`, and `false` collapse to an empty string for clean
+ * conditional rules. The `css` name also lets editors and the Format docs
+ * highlighter treat the contents as CSS.
+ */
+declare function css(parts: TemplateStringsArray, ...vals: unknown[]): string;
+//#endregion
+export { Counter, CounterDef, type CounterDefProps, type CounterProps, type CounterStyle, Document, type DocumentProps, Flow, type FlowProps, type FontMode, Footnote, Footnotes, type FootnotesProps, Layout, type LayoutProps, Numbering, type NumberingProps, NumberingRule, type NumberingRuleProps, PageBreak, PageCount, type PageCountProps, PageNumber, type PageNumberProps, type PaginationStrategy, Ref, type RefProps, type RenderProps, Scope, type ScopeProps, SplitGranularity, Stream, TableOfContents, type TableOfContentsProps, TocLeader, css };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/Document.tsx","../src/Layout.tsx","../src/Flow.tsx","../src/Stream.tsx","../src/PageBreak.tsx","../src/PageCounter.tsx","../src/PageNumber.tsx","../src/PageCount.tsx","../src/Counter.tsx","../src/Numbering.tsx","../src/Scope.tsx","../src/Ref.tsx","../src/TableOfContents.tsx","../src/Footnote.tsx","../src/Footnotes.tsx","../src/utils.ts"],"sourcesContent":[],"mappings":"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"}