@abide/abide 0.118.0 → 0.119.0

package/src/compiler/formatDiagnosis.ts

@@ -1,4 +1,5 @@
 import { relative } from 'node:path' // bun exposes no path helpers of its own
+
 import type { Diagnosis } from './TypeSession.ts'
 
 /**

package/src/compiler/handlersUnder.ts

@@ -11,12 +11,13 @@
 
 import type { Mount } from '#server/answerRpc.ts'
 import { frameworkRouteRefusal } from '#server/appTree.ts'
+import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import { surfaceName } from '#server/surfaceOf.ts'
 import { PRIVATE_HANDLERS_ADDRESS } from '#shared/ADDRESSES.ts'
 import { parseRoutePattern } from '#shared/routePattern.ts'
+
 import type { PlacedHandler, PlacedSource } from './appLayout.ts'
 import { declaredExports } from './declaredExports.ts'
-import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import type { Refusals } from './Refusals.ts'
 import type { Diagnosis, TypeSession } from './TypeSession.ts'
 

package/src/compiler/hookCalls.ts

@@ -1,4 +1,5 @@
 import { SHARED_SPECIFIER } from '#shared/SPECIFIERS.ts'
+
 import { importStatements } from './splitImports.ts'
 import { type Token, tokenize } from './tokenize.ts'
 

package/src/compiler/lineOf.ts

@@ -20,6 +20,23 @@ export function lineOf(
     return { line, column: end - lineStart + 1 }
 }
 
+/**
+ * The protocol's `{ line, character }`, from 0, as an offset into `text`. A character is a UTF-16
+ * code unit in the protocol and in a JavaScript string alike.
+ */
+export function offsetOf(
+    text: string,
+    position: { line: number; character: number },
+): number {
+    let at = 0
+    for (let line = 0; line < position.line; line += 1) {
+        const end = text.indexOf('\n', at)
+        if (end === -1) return text.length
+        at = end + 1
+    }
+    return at + position.character
+}
+
 /** abide's own finding at `offset` into `text`, or at line 0 where the text was not handed in. */
 export function diagnosisAt(
     path: string,

package/src/compiler/matchersOf.ts

@@ -9,6 +9,7 @@
 // layout whose segment refused it would be wrapped by a layout no address of its own reaches.
 
 import { parseRoutePattern } from '#shared/routePattern.ts'
+
 import { matcherOf } from './paramFile.ts'
 import type { Refusals } from './Refusals.ts'
 
@@ -16,7 +17,12 @@ import type { Refusals } from './Refusals.ts'
 export type MountedTree = { directory: string; at: string; params: string[] }
 
 /** A file with a route: its path, the name refusals give it, and the position it answers by. */
-type Routed = { path: string; relative: string; position: string; route: string }
+type Routed = {
+    path: string
+    relative: string
+    position: string
+    route: string
+}
 
 /**
  * Each routed file's matchers, by its path: every name its route's segments give, to the anchored
@@ -39,7 +45,10 @@ export async function matchersOf(
     for (const tree of trees) all.push(...tree.params)
     for (const path of all) {
         if (sources.has(path)) continue
-        const matcher = matcherOf(labelOf(root, path), await Bun.file(path).text())
+        const matcher = matcherOf(
+            labelOf(root, path),
+            await Bun.file(path).text(),
+        )
         if (matcher instanceof Error) {
             refusals.at(path, matcher)
             sources.set(path, undefined)
@@ -79,7 +88,8 @@ export async function matchersOf(
                 continue
             }
             const other = atPosition.get(shape)
-            if (other === undefined) atPosition.set(shape, { found, file: file.relative })
+            if (other === undefined)
+                atPosition.set(shape, { found, file: file.relative })
             else if (other.found !== found)
                 refusals.at(
                     file.path,

package/src/compiler/mountsOf.ts

@@ -10,8 +10,10 @@
 
 import { realpathSync, statSync } from 'node:fs' // bun exposes no sync stat or realpath of its own
 import { dirname, relative, resolve } from 'node:path' // bun exposes no path helpers of its own
+
 import { appFiles } from '#server/appTree.ts'
 import { placeOf } from '#server/placement.ts'
+
 import { nearest } from './nearest.ts'
 import { type AbideFile, scriptBodies } from './parseAbide.ts'
 import { Refusals } from './Refusals.ts'

package/src/compiler/paramFile.ts

@@ -9,6 +9,7 @@
 // and still never admit `.` or `..`, which the URL parser collapses into another route.
 
 import { SyntaxKind } from 'typescript/unstable/ast'
+
 import { tokenize } from './tokenize.ts'
 
 /** The name a param file declares: its file name before `.param.ts`. */

package/src/compiler/parseAbide.ts

@@ -1,16 +1,18 @@
 import { SyntaxKind } from 'typescript/unstable/ast'
+
 import { URL_ATTRIBUTES } from '#shared/URL_ATTRIBUTES.ts'
+
 import { isComponentTag, isSlot, propKeyOf } from './classifyTemplate.ts'
 import { decodeCharacterReferences } from './decodeCharacterReferences.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
 import { lineOf } from './lineOf.ts'
 import { PositionedRefusal } from './PositionedRefusal.ts'
-import { TEMPLATE_BLOCKS } from './TEMPLATE_BLOCKS.ts'
 import { importedNames } from './splitImports.ts'
+import { TEMPLATE_BLOCKS } from './TEMPLATE_BLOCKS.ts'
 import {
     type Attribute,
-    type Branch,
     bodiesOf,
+    type Branch,
     type ElementNode,
     type ForBlock,
     type InlineComponent,
@@ -106,6 +108,8 @@ type Origins = {
     names: Map<object, number>
     /** 38.116 — per element closed by a tag of its own, where that close tag's name starts. */
     closes: Map<object, number>
+    /** Where each block body's `<script>` setup starts — 32.48, 14.8. */
+    setups: number[]
 }
 
 /**
@@ -216,6 +220,7 @@ export function parseAbide(source: string): AbideFile {
         bindings: new Map(),
         names: new Map(),
         closes: new Map(),
+        setups: [],
     }
     const root: TemplateNode[] = []
     // The open elements, innermost last. `root` is the floor and is never popped.
@@ -365,8 +370,7 @@ export function parseAbide(source: string): AbideFile {
                 if (block === styles && blocks.length > 0) {
                     const owner = bodyOf(
                         blocks[blocks.length - 1] as
-                            | TemplateNode
-                            | InlineComponent,
+                            TemplateNode | InlineComponent,
                     )
                     owner.style =
                         owner.style === null
@@ -377,8 +381,7 @@ export function parseAbide(source: string): AbideFile {
                 }
                 if (block === scripts && blocks.length > 0) {
                     const holder = blocks[blocks.length - 1] as
-                        | TemplateNode
-                        | InlineComponent
+                        TemplateNode | InlineComponent
                     const owner = bodyOf(holder)
                     if (owner.setup !== null)
                         throw new Error(
@@ -388,6 +391,7 @@ export function parseAbide(source: string): AbideFile {
                         )
                     owner.setup = { text: raw.body }
                     origins.holders.set(owner.setup, tag.end)
+                    origins.setups.push(tag.end)
                     at = raw.end
                     continue
                 }
@@ -1072,7 +1076,7 @@ function rawBody(
  * already `trim()`s for this, which is one question with two answers until now — so the end is
  * handed back rather than recomputed from the tag's length.
  */
-function closeTagAt(
+export function closeTagAt(
     source: string,
     tag: string,
     from: number,
@@ -1113,6 +1117,9 @@ function pushText(
     return next
 }
 
+/** The ` if` after `{:else` — a whole word, so `{:elseif}` and `{:else ifValid}` are not one. */
+export const ELSE_IF = /^\s+if(?=[\s(])/
+
 /**
  * Where the condition on a `{:else …}` arm starts in `inner`, or its end for the bare `{:else}`
  * that always takes.
@@ -1124,7 +1131,7 @@ function pushText(
 function elseSubjectAt(inner: string): number {
     const rest = inner.slice(':else'.length)
     if (rest.trim() === '') return inner.length
-    const keyword = /^\s+if(?=[\s(])/.exec(rest)
+    const keyword = ELSE_IF.exec(rest)
     if (keyword === null || rest.slice(keyword[0].length).trim() === '')
         throw new Error(
             `abide: {${inner}} is not a control block. Write {:else} or {:else if <condition>}.`,
@@ -1147,28 +1154,18 @@ function trimmed(
 }
 
 /**
- * Parses a `{#for}` header into its item, index, subject and key.
- *
- * `item, index of list by key` — `index` and `by` are optional, and everything after `of` up to
- * a top-level `by` is the subject. Split on the KEYWORDS rather than on commas, because the
- * subject may hold both.
+ * The `of`, the `,` and the `by` that divide a `{#for}` header — each the first at depth zero.
  *
- * THE SEPARATOR IS THE ONE AT DEPTH ZERO AND OUTSIDE A STRING — all three of them, and each was
- * wrong its own way. `{#for { id, name } of rows}` split on the pattern's own comma and the item
- * became `{ id`, which the emitters write straight into a parameter list. `{#for x of
- * names.filter(n => n !== "run by me")}` split on the ` by ` inside the string literal and the
- * subject ended mid-quote. One scanner for all three rather than one fix for the comma.
+ * THE HEADER IS TOKENS, read by the scanner a slot is: an `of`, a `,` or a `by` inside a string,
+ * a call or an object pattern is the expression's own, and only one at depth zero divides the
+ * header. `by` is a word rather than a keyword, so a member named `by` is not one.
  */
-function forBlock(
-    file: string,
-    header: { text: string; at: number },
-    origins: Origins,
-): ForBlock {
-    const source = header.text
-    // THE HEADER IS TOKENS, read by the scanner a slot is: an `of`, a `,` or a `by` inside a string,
-    // a call or an object pattern is the expression's own, and only one at depth zero divides the
-    // header. `by` is a word rather than a keyword, so a member named `by` is not one.
-    const tokens = tokenize(source)
+export function forSeparators(header: string): {
+    of: Token | undefined
+    comma: Token | undefined
+    by: Token | undefined
+} {
+    const tokens = tokenize(header)
     let depth = 0
     let of: Token | undefined
     let comma: Token | undefined
@@ -1191,6 +1188,29 @@ function forBlock(
         )
             by = token
     }
+    return { of, comma, by }
+}
+
+/**
+ * Parses a `{#for}` header into its item, index, subject and key.
+ *
+ * `item, index of list by key` — `index` and `by` are optional, and everything after `of` up to
+ * a top-level `by` is the subject. Split on the KEYWORDS rather than on commas, because the
+ * subject may hold both.
+ *
+ * THE SEPARATOR IS THE ONE AT DEPTH ZERO AND OUTSIDE A STRING — all three of them, and each was
+ * wrong its own way. `{#for { id, name } of rows}` split on the pattern's own comma and the item
+ * became `{ id`, which the emitters write straight into a parameter list. `{#for x of
+ * names.filter(n => n !== "run by me")}` split on the ` by ` inside the string literal and the
+ * subject ended mid-quote. One scanner for all three rather than one fix for the comma.
+ */
+function forBlock(
+    file: string,
+    header: { text: string; at: number },
+    origins: Origins,
+): ForBlock {
+    const source = header.text
+    const { of, comma, by } = forSeparators(source)
     // A `{#for}` with nothing to iterate rendered as a block over the subject '' — zero rows,
     // forever, with nothing saying why (32.22 is an ABSENT subject, not a missing one).
     if (of === undefined)

package/src/compiler/projectShadow.ts

@@ -1,14 +1,16 @@
 import { SyntaxKind } from 'typescript/unstable/ast'
+
 import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import { isEventName } from '#shared/isEventName.ts'
+
 import { isComponentTag, propKeyOf } from './classifyTemplate.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
+import type { AbideFile } from './parseAbide.ts'
 import {
     type Position,
     type PositionKind,
     PositionTable,
 } from './PositionTable.ts'
-import type { AbideFile } from './parseAbide.ts'
 import {
     attributedImports,
     IMPORT_ATTRIBUTES,
@@ -501,12 +503,17 @@ function project(file: AbideFile): Projection {
                 body(node.children, node.components)
                 continue
             }
-            // 32.16 — the catch arm binds the failure, and the checker has to see the name.
+            // 32.16 — the catch arm binds the failure, and the checker has to see the name. Read once
+            // with `void`, as a `catch` binding is never reported unused. An arm that names none binds
+            // nothing.
             if (node.block === 'try') {
                 const [tried, caught] = node.branches as [Branch, Branch]
                 text += '{\n'
                 inBody(tried)
-                text += `}\n{ const ${node.error === '' ? '__failure' : node.error}: any = undefined\n`
+                text +=
+                    node.error === ''
+                        ? '}\n{\n'
+                        : `}\n{ const ${node.error}: any = undefined; void ${node.error}\n`
                 inBody(caught)
                 text += '}\n'
                 continue

package/src/compiler/reactiveOptions.ts

@@ -11,6 +11,7 @@ import {
     isObjectLiteralExpression,
     isPropertyAssignment,
 } from 'typescript/unstable/ast/is'
+
 import type { Method } from '#shared/rpc.ts'
 
 /**

package/src/compiler/reactiveTypes.ts

@@ -4,18 +4,19 @@ import {
     isVariableDeclaration,
 } from 'typescript/unstable/ast/is'
 import {
-    type Symbol as CheckedSymbol,
     type Checker,
     ObjectFlags,
     type ObjectType,
     type Project,
     SignatureKind,
+    type Symbol as CheckedSymbol,
     type Type,
     TypeFlags,
     type TypeParameter,
     type TypeReference,
     type UnionOrIntersectionType,
 } from 'typescript/unstable/async'
+
 import { aliasedSymbol } from './aliasedSymbol.ts'
 
 // WHAT THE CHECKER SAYS A NAME HOLDS, asked by both of the session's jobs over one snapshot: the

package/src/compiler/readsIn.ts

@@ -26,13 +26,14 @@ import {
     isVariableStatement,
 } from 'typescript/unstable/ast/is'
 import {
-    type Symbol as CheckedSymbol,
     type Checker,
     SignatureKind,
+    type Symbol as CheckedSymbol,
     SymbolFlags,
     type Type,
     TypeFlags,
 } from 'typescript/unstable/async'
+
 import { aliasedSymbol } from './aliasedSymbol.ts'
 import { CheckerAnswer } from './CheckerAnswer.ts'
 import {
@@ -45,13 +46,13 @@ import {
     TRANSPARENT,
 } from './classifyRead.ts'
 import type { Finding } from './Finding.ts'
+import type { AbideFile } from './parseAbide.ts'
 import {
     holdsReactive,
     type Position,
     type PositionKind,
     type PositionTable,
 } from './PositionTable.ts'
-import type { AbideFile } from './parseAbide.ts'
 import { INLINE_PROPS, type Span } from './projectShadow.ts'
 import { REACTIVE_MEMBERS } from './REACTIVE_MEMBERS.ts'
 import { optionNamed, reactiveOptions } from './reactiveOptions.ts'

package/src/compiler/renderMarkup.ts

@@ -1,10 +1,10 @@
-import { REGION_CLOSE, REGION_OPEN, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { anchorMarkup, regionMarkup } from '#shared/anchorMarkup.ts'
+import { REGION_CLOSE, REGION_OPEN, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { armAnchor } from '#shared/armAnchor.ts'
 import { CHILDREN } from '#shared/CHILDREN.ts'
 import { escapeQuote } from '#shared/escapeText.ts'
 import { headKeyOf } from '#shared/headKeyOf.ts'
-import { Cursor, type PlacedNode, placeTemplate } from './Cursor.ts'
+
 import {
     attributeOf,
     type ClassifiedAttribute,
@@ -15,6 +15,7 @@ import {
     isSlot,
     type MergeGroup,
 } from './classifyTemplate.ts'
+import { Cursor, type PlacedNode, placeTemplate } from './Cursor.ts'
 import { invocationProps, passedName } from './invocationProps.ts'
 import { type Lowering, PROPS } from './Lowering.ts'
 import type { AbideFile } from './parseAbide.ts'

package/src/compiler/resolverIn.ts

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs' // bun exposes no sync existence check or read of its own
 import { dirname, posix } from 'node:path' // bun exposes no path helpers of its own
+
 import { resolvedFile } from '#server/abideModules.ts'
+
 import { nearest } from './nearest.ts'
 
 /**

package/src/compiler/sameTemplate.ts

@@ -0,0 +1,150 @@
+import { SyntaxKind } from 'typescript/unstable/ast'
+
+import type { AbideFile } from './parseAbide.ts'
+import type { Body, InlineComponent, TemplateNode } from './TemplateNode.ts'
+import { tokenize } from './tokenize.ts'
+
+// 38.127 — WHAT `abide format` MAY CHANGE, and nothing else: the whitespace a browser collapses, a
+// run's indentation where 33.17 and 33.18 read only its kind, and the code `bun fmt` printed, read as
+// its tokens — a script block's in any order, since `sortImports` moves its imports. Everything else — a tag, an attribute's text, a block's shape, a line inside a template
+// literal — is compared as the parser read it.
+
+/** Whether `before` and `after` are one template, under what `abide format` may change. 38.127. */
+export function sameTemplate(before: AbideFile, after: AbideFile): boolean {
+    return shapeOf(before) === shapeOf(after)
+}
+
+function shapeOf(file: AbideFile): string {
+    const parts: string[] = []
+    for (const code of file.modules) parts.push(blockShape(code))
+    for (const code of file.servers) parts.push(blockShape(code))
+    for (const code of file.scripts) parts.push(blockShape(code))
+    for (const style of file.styles) parts.push(styleShape(style))
+    parts.push(file.generics ?? '')
+    nodesShape(file.head, parts)
+    if (file.document !== undefined) {
+        nodesShape([file.document.html], parts)
+        nodesShape([file.document.body], parts)
+    }
+    nodesShape(file.template, parts)
+    for (const component of file.components) componentShape(component, parts)
+    return parts.join('\u0000')
+}
+
+function nodesShape(nodes: TemplateNode[], parts: string[]): void {
+    for (const node of nodes) {
+        if (node.kind === 'text') {
+            parts.push(`text ${textShape(node.text)}`)
+            continue
+        }
+        if (node.kind === 'expression') {
+            parts.push(`slot ${codeShape(node.source)}`)
+            continue
+        }
+        if (node.kind === 'element') {
+            parts.push(`<${node.tag}`)
+            for (const attribute of node.attributes)
+                parts.push(
+                    attribute.expression
+                        ? `${attribute.name}={${codeShape(attribute.value)}}`
+                        : `${attribute.name}=${attribute.value}`,
+                )
+            nodesShape(node.children, parts)
+            for (const component of node.components)
+                componentShape(component, parts)
+            for (const component of node.passed)
+                componentShape(component, parts)
+            parts.push(`</${node.tag}>`)
+            continue
+        }
+        if (node.block === 'for') {
+            parts.push(
+                `{#for ${codeShape(node.item)},${codeShape(node.index)} of ${codeShape(node.subject)} by ${codeShape(node.key)}`,
+            )
+            bodyShape(node, parts)
+        } else {
+            parts.push(
+                node.block === 'try'
+                    ? `{#try ${node.error}`
+                    : `{#${node.block}`,
+            )
+            for (const branch of node.branches) {
+                parts.push(`{:${codeShape(branch.subject)}`)
+                bodyShape(branch, parts)
+            }
+        }
+        parts.push('{/}')
+    }
+}
+
+function bodyShape(body: Body, parts: string[]): void {
+    parts.push(
+        body.setup === null ? '' : blockShape(body.setup.text),
+        body.style === null ? '' : styleShape(body.style),
+    )
+    nodesShape(body.children, parts)
+    for (const component of body.components) componentShape(component, parts)
+}
+
+function componentShape(component: InlineComponent, parts: string[]): void {
+    parts.push(
+        `{#component ${component.name}(${component.pattern}: ${component.type})`,
+    )
+    bodyShape(component, parts)
+    parts.push('{/component}')
+}
+
+/**
+ * A text node as the browser renders it: within text, every whitespace run holding a newline is one
+ * space however it is indented. A node that is whitespace alone keeps its KIND — a newline alone, or
+ * one carrying indentation — since 33.17 and 33.18 drop the two apart.
+ */
+function textShape(text: string): string {
+    if (text.trim() === '') return /[ \t]/.test(text) ? '\n ' : '\n'
+    return text.replace(/\s*\n\s*/g, '\n')
+}
+
+/** Code as its tokens, in order. */
+function codeShape(code: string): string {
+    return tokensOf(code).join(' ')
+}
+
+/** A script block's code as its tokens in any order: `bun fmt`'s `sortImports` moves its imports. */
+function blockShape(code: string): string {
+    return tokensOf(code).sort().join(' ')
+}
+
+/**
+ * Code's tokens, with what a printer adds or drops at will taken out: the separators `;` and `,`,
+ * the parentheses, and how a string or a number is spelled. A template literal's text is a token,
+ * so a line moved inside one is a different token.
+ */
+function tokensOf(code: string): string[] {
+    const tokens: string[] = []
+    for (const token of tokenize(code))
+        switch (token.kind) {
+            case SyntaxKind.SemicolonToken:
+            case SyntaxKind.CommaToken:
+            case SyntaxKind.OpenParenToken:
+            case SyntaxKind.CloseParenToken:
+                continue
+            case SyntaxKind.StringLiteral:
+                tokens.push(
+                    JSON.stringify(
+                        token.text.slice(1, -1).replace(/\\(['"])/g, '$1'),
+                    ),
+                )
+                continue
+            case SyntaxKind.NumericLiteral:
+                tokens.push(String(Number(token.text.replaceAll('_', ''))))
+                continue
+            default:
+                tokens.push(token.text)
+        }
+    return tokens
+}
+
+/** A style with its whitespace and its `;`s taken out, which CSS reads none of outside a string. */
+function styleShape(style: string): string {
+    return style.replace(/[\s;]+/g, '')
+}

package/src/compiler/scaffold.ts

@@ -5,6 +5,7 @@
 // half-made project finishes it rather than overwriting it.
 
 import { withoutTrailingSlash } from '#server/withoutTrailingSlash.ts'
+
 import abidePackage from '../../package.json' with { type: 'json' }
 import { COMPILER_OPTIONS } from './writeDefaultProject.ts'
 
@@ -39,7 +40,7 @@ const SOURCE_ALIAS = { '#src/*': ['./src/*', './src/*.ts'] }
  * lands first on the PATH inside `bun run`, shadowing the bun that runs everything else.
  */
 export const BUNFIG =
-    '# 38.122 — a peer is not installed: an installed `bun` would shadow this one inside `bun run`.\n[install]\npeer = false\n\n# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n'
+    '# 38.122 — a peer is not installed: an installed `bun` would shadow this one inside `bun run`.\n[install]\npeer = false\n\n# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n\n# What `bun fmt` and `abide format` print.\n[fmt]\ntabWidth = 4\nsemi = false\nsingleQuote = true\nsortImports = true\n'
 
 // WRITTEN, NOT COPIED, beside the manifests: a packer drops a `bunfig.toml` or a `.gitignore` from
 // the tarball (`bun pm pack` both, `npm pack` the second), so neither survives as a starter file.
@@ -55,6 +56,8 @@ function filesFor(name: string): Record<string, string> {
                 scripts: {
                     // 38.103 — the checker over `.abide`, which `tsc` does not read.
                     check: 'abide check',
+                    // 38.125 — every `.abide`, then every other file `bun fmt` reads.
+                    format: 'abide format && bun fmt',
                     dev: 'abide dev',
                     build: 'abide build',
                     start: 'abide start',
@@ -101,16 +104,6 @@ function filesFor(name: string): Record<string, string> {
             null,
             4,
         )}\n`,
-        'biome.json': `${JSON.stringify(
-            {
-                formatter: { indentStyle: 'space', indentWidth: 4 },
-                javascript: {
-                    formatter: { quoteStyle: 'single', semicolons: 'asNeeded' },
-                },
-            },
-            null,
-            4,
-        )}\n`,
     }
 }