openapi-typesafe 0.0.0 → 1.0.0-rc.1

package/src/application/transform/document/root-type-aliases.ts

@@ -0,0 +1,107 @@
+import { irRaw } from "../../../domain/ir/constructors.js";
+import type { IrDeclaration, IrTypeAliasDeclaration } from "../../../domain/ir/nodes.js";
+import { escapeSingleQuotedText } from "../../../domain/ir/raw-text-escapes.js";
+import type { ComponentKind } from "../../../domain/openapi/components-object.js";
+import { globalTypeReferences } from "./global-type-references.js";
+
+/** The `--root-types` aliases: `export type Pet = components['schemas']['Pet'];`. */
+
+const REFERENCE_PREFIX = "components['";
+
+/** The alias of one component. */
+export function rootTypeAlias(
+  name: string,
+  kind: ComponentKind,
+  item: string,
+): IrTypeAliasDeclaration {
+  return {
+    kind: "typeAlias",
+    name,
+    isExported: true,
+    // The original writes the reference as text, with single quotes, and did not escape the
+    // name: a quote in it could add code to the generated file (intentional fix).
+    type: irRaw(`${REFERENCE_PREFIX}${kind}']['${escapeSingleQuotedText(item)}']`),
+    comments: [],
+  };
+}
+
+function isRootTypeAlias(declaration: IrDeclaration): declaration is IrTypeAliasDeclaration {
+  return (
+    declaration.kind === "typeAlias" &&
+    declaration.type.kind === "raw" &&
+    declaration.type.text.startsWith(REFERENCE_PREFIX)
+  );
+}
+
+/**
+ * The type names the footer declares that an alias must not take: enums, and helper types such as
+ * `WithRequired`. Value declarations (`--enum-values` arrays) live in another namespace.
+ */
+function footerTypeNames(declarations: readonly IrDeclaration[]): Set<string> {
+  return new Set(
+    declarations.flatMap((declaration) => {
+      if (declaration.kind === "enum") {
+        return [declaration.name];
+      }
+      return declaration.kind === "rawDeclaration" && declaration.name !== undefined
+        ? [declaration.name]
+        : [];
+    }),
+  );
+}
+
+function declaredNames(declarations: readonly IrDeclaration[]): Set<string> {
+  return new Set(
+    declarations.flatMap((declaration) =>
+      "name" in declaration && declaration.name !== undefined ? [declaration.name] : [],
+    ),
+  );
+}
+
+function freeName(name: string, taken: ReadonlySet<string>): string {
+  let candidate = `${name}_2`;
+  for (let counter = 3; taken.has(candidate); counter++) {
+    candidate = `${name}_${counter}`;
+  }
+  return candidate;
+}
+
+/**
+ * Rename each root alias whose name an enum or a helper type of the footer also declares, or that
+ * shadows a TypeScript global type the output refers to (`Record` in `Record<string, never>`), to
+ * the next free `Name_2`, `Name_3`, … (the suffix `--root-types` uses for its own conflicts). The
+ * footer and the globals keep their names, because the generated types refer to them. Before, the
+ * output did not compile (enums: upstream #2099, #2341, #2206; helpers: a schema named
+ * `WithRequired`, roadmap R11; globals: TS2315). Other declarations are returned unchanged.
+ *
+ * With the `root-type-numbering` fix (ADR-021, roadmap R13, backlog 30) the body also holds the
+ * aliases a later schema of one exported name took the name from, after the other aliases and
+ * under that same name. Each gets the next free number in body order, after the alias that kept
+ * the name got its own: so the fix only adds exports, and every other alias keeps the name it has
+ * without the fix.
+ */
+export function renameTakenAliases<T extends IrDeclaration>(
+  body: readonly T[],
+  footer: readonly IrDeclaration[],
+  closing: readonly IrDeclaration[] = [],
+): T[] {
+  const reserved = footerTypeNames(footer);
+  for (const name of globalTypeReferences([...body, ...footer, ...closing])) {
+    reserved.add(name);
+  }
+  const taken = declaredNames([...body, ...footer, ...closing]);
+  const aliasNames = new Set<string>();
+  return body.map((declaration) => {
+    if (!isRootTypeAlias(declaration)) {
+      return declaration;
+    }
+    const isRepeated = aliasNames.has(declaration.name);
+    aliasNames.add(declaration.name);
+    if (!isRepeated && !reserved.has(declaration.name)) {
+      return declaration;
+    }
+    const name = freeName(declaration.name, taken);
+    taken.add(name);
+    return { ...declaration, name };
+  });
+}

package/src/application/transform/document/template-key-match.ts

@@ -0,0 +1,183 @@
+/**
+ * Whether a key type is assignable to a template literal key type, decided the way TypeScript's
+ * checker decides it (`inferFromLiteralPartsToTemplateLiteral` and
+ * `isValidTypeForTemplateLiteralPlaceholder` in TypeScript 5 and 6). An index signature checks
+ * exactly the keys that are assignable to its key type, so the overlap check must match the
+ * checker, not the strings a template stands for: the checker matches each text of the target at
+ * its first occurrence, so it misses some keys a regular expression would match, and a key it
+ * misses is never checked against the signature.
+ */
+
+/** A placeholder type of a template, after `${boolean}` became the texts `true` and `false`. */
+export type TemplatePlaceholder = "string" | "number";
+
+/**
+ * A key type as TypeScript stores a template literal: texts around placeholders, one more text
+ * than placeholders. A string literal is one text and no placeholder.
+ */
+export interface TemplateShape {
+  readonly texts: readonly string[];
+  readonly types: readonly TemplatePlaceholder[];
+}
+
+/** The text at an index of the shape; every caller passes one of `0 .. types.length`. */
+function textAt(shape: TemplateShape, index: number): string {
+  return shape.texts[index] as string;
+}
+
+/** The type the checker infers for one target placeholder: a text, or a slice of the source. */
+type InferredMatch =
+  | { readonly kind: "text"; readonly text: string }
+  | { readonly kind: "template"; readonly shape: TemplateShape };
+
+/** TypeScript's `isValidNumberString(text, false)`: a text that converts to a finite number. */
+export function isNumberText(text: string): boolean {
+  return text !== "" && Number.isFinite(Number(text));
+}
+
+/** Whether the inferred type fits a placeholder: any string for `string`, a number for `number`. */
+function isValidMatch(match: InferredMatch, placeholder: TemplatePlaceholder): boolean {
+  if (placeholder === "string") {
+    return true;
+  }
+  if (match.kind === "text") {
+    return isNumberText(match.text);
+  }
+  const { texts, types } = match.shape;
+  return texts.length === 2 && texts[0] === "" && texts[1] === "" && types[0] === "number";
+}
+
+/** The state of the scan through the source: the current text and the position in it. */
+interface Cursor {
+  readonly segment: number;
+  readonly position: number;
+}
+
+/** The scan of `inferFromLiteralPartsToTemplateLiteral`, over one source and one target. */
+class LiteralPartsScan {
+  private readonly matches: InferredMatch[] = [];
+  private cursor: Cursor;
+  private readonly source: TemplateShape;
+  private readonly lastSourceIndex: number;
+  private readonly remainingEndText: string;
+
+  constructor(source: TemplateShape, startPosition: number, endTextLength: number) {
+    this.source = source;
+    this.lastSourceIndex = source.texts.length - 1;
+    const endText = textAt(source, this.lastSourceIndex);
+    this.remainingEndText = endText.slice(0, endText.length - endTextLength);
+    this.cursor = { segment: 0, position: startPosition };
+  }
+
+  /** The matches for the target's texts between its first and last; null when one is missing. */
+  run(delimiters: readonly string[]): readonly InferredMatch[] | null {
+    for (const delimiter of delimiters) {
+      if (!this.matchDelimiter(delimiter)) {
+        return null;
+      }
+    }
+    this.addMatch(this.lastSourceIndex, this.sourceText(this.lastSourceIndex).length);
+    return this.matches;
+  }
+
+  private matchDelimiter(delimiter: string): boolean {
+    const { segment, position } = this.cursor;
+    if (delimiter.length > 0) {
+      const found = this.find(delimiter);
+      if (found === null) {
+        return false;
+      }
+      this.addMatch(found.segment, found.position);
+      this.cursor = { ...this.cursor, position: this.cursor.position + delimiter.length };
+      return true;
+    }
+    if (position < this.sourceText(segment).length) {
+      this.addMatch(segment, position + 1);
+      return true;
+    }
+    if (segment < this.lastSourceIndex) {
+      this.addMatch(segment + 1, 0);
+      return true;
+    }
+    return false;
+  }
+
+  /** The first occurrence of the delimiter at or after the cursor, in this or a later text. */
+  private find(delimiter: string): Cursor | null {
+    let { segment, position } = this.cursor;
+    while (segment < this.source.texts.length) {
+      const index = this.sourceText(segment).indexOf(delimiter, position);
+      if (index >= 0) {
+        return { segment, position: index };
+      }
+      segment += 1;
+      position = 0;
+    }
+    return null;
+  }
+
+  private sourceText(index: number): string {
+    return index < this.lastSourceIndex ? textAt(this.source, index) : this.remainingEndText;
+  }
+
+  private addMatch(segment: number, position: number): void {
+    const start = this.cursor;
+    if (segment === start.segment) {
+      const text = this.sourceText(segment).slice(start.position, position);
+      this.matches.push({ kind: "text", text });
+    } else {
+      const texts = [
+        textAt(this.source, start.segment).slice(start.position),
+        ...this.source.texts.slice(start.segment + 1, segment),
+        this.sourceText(segment).slice(0, position),
+      ];
+      const types = this.source.types.slice(start.segment, segment);
+      this.matches.push({ kind: "template", shape: { texts, types } });
+    }
+    this.cursor = { segment, position };
+  }
+}
+
+/** The checker's inferences for the target's placeholders; null when the texts do not fit. */
+function inferMatches(
+  source: TemplateShape,
+  target: TemplateShape,
+): readonly InferredMatch[] | null {
+  const sourceStart = textAt(source, 0);
+  const sourceEnd = textAt(source, source.texts.length - 1);
+  const targetStart = textAt(target, 0);
+  const targetEnd = textAt(target, target.texts.length - 1);
+  const isTooShort =
+    source.texts.length === 1 && sourceStart.length < targetStart.length + targetEnd.length;
+  if (isTooShort || !sourceStart.startsWith(targetStart) || !sourceEnd.endsWith(targetEnd)) {
+    return null;
+  }
+  const scan = new LiteralPartsScan(source, targetStart.length, targetEnd.length);
+  return scan.run(target.texts.slice(1, -1));
+}
+
+function haveSameTexts(source: TemplateShape, target: TemplateShape): boolean {
+  return (
+    source.texts.length === target.texts.length &&
+    source.texts.every((text, index) => text === target.texts[index])
+  );
+}
+
+/**
+ * Whether the source key type is assignable to the target template. Templates with the same texts
+ * compare placeholder by placeholder (`inferTypesFromTemplateLiteralType`).
+ */
+export function isAssignableToTemplate(source: TemplateShape, target: TemplateShape): boolean {
+  if (source.types.length > 0 && haveSameTexts(source, target)) {
+    return source.types.every((type, index) => {
+      const placeholder = target.types[index];
+      return placeholder === "string" || type === placeholder;
+    });
+  }
+  const matches = inferMatches(source, target);
+  const isEveryMatchValid = matches?.every((match, index) => {
+    const placeholder = target.types[index];
+    return placeholder !== undefined && isValidMatch(match, placeholder);
+  });
+  return isEveryMatchValid === true;
+}

package/src/application/transform/document/type-assignability.ts

@@ -0,0 +1,268 @@
+import { irBoolean } from "../../../domain/ir/constructors.js";
+import type {
+  IrIndexSignature,
+  IrObjectType,
+  IrPropertySignature,
+  IrType,
+  IrUnionType,
+} from "../../../domain/ir/nodes.js";
+import {
+  type Assignability,
+  crossCategoryRelation,
+  everyOf,
+  primitiveRelation,
+  someOf,
+} from "./assignability.js";
+import type { DeclaredTypeLookup } from "./declared-types.js";
+import { type IrListType, relateLists } from "./list-assignability.js";
+import { createTypeKey } from "./type-key.js";
+import {
+  indexSignaturesOf,
+  nameOf,
+  propertiesOf,
+  readType,
+  TypeResolution,
+} from "./type-resolution.js";
+
+/**
+ * Whether TypeScript accepts one type where another is expected (`strict`, without
+ * `exactOptionalPropertyTypes`), for the `--path-params-as-types` overlap check. It follows the
+ * checker's rules for the types the generator writes: unions, intersections, objects with optional
+ * properties and index signatures, weak types, arrays, tuples, literals and keywords, and the
+ * references to declarations of the document. A pair it does not model (a utility type, raw text)
+ * is undecided unless both are the same type, and an undecided pair keeps the original output.
+ */
+
+/** Results by source type, then by target type. */
+type PairResults = Map<IrType, Map<IrType, Assignability>>;
+
+function resultOf(results: PairResults, source: IrType, target: IrType): Assignability | undefined {
+  return results.get(source)?.get(target);
+}
+
+function setResult(
+  results: PairResults,
+  pair: { readonly source: IrType; readonly target: IrType },
+  value: Assignability,
+): void {
+  const byTarget = results.get(pair.source) ?? new Map<IrType, Assignability>();
+  byTarget.set(pair.target, value);
+  results.set(pair.source, byTarget);
+}
+
+/** A weak type has only optional properties; TypeScript rejects a source sharing none (TS2559). */
+function isWeakTypeRejected(source: IrObjectType, target: IrObjectType): boolean {
+  const targetProperties = [...propertiesOf(target).values()];
+  const isWeak =
+    targetProperties.length > 0 &&
+    indexSignaturesOf(target).length === 0 &&
+    targetProperties.every((property) => property.isOptional);
+  const sourceNames = [...propertiesOf(source).keys()];
+  return (
+    isWeak &&
+    sourceNames.length > 0 &&
+    !sourceNames.some((name) => targetProperties.some((property) => nameOf(property) === name))
+  );
+}
+
+function isStringIndex(signature: IrIndexSignature): boolean {
+  return signature.parameterType.kind === "keyword" && signature.parameterType.keyword === "string";
+}
+
+/** `boolean` as the checker stores it: the union `true | false`. */
+const BOOLEAN_MEMBERS: readonly IrType[] = [irBoolean(true), irBoolean(false)];
+
+/**
+ * The members a source is compared by, one by one, or null for a source compared as a whole.
+ * `boolean` counts as `true | false` against a union, which it fits though it fits neither member
+ * alone; `string` and `number` are no finite unions, so no literal union holds all their values.
+ */
+function sourceUnionMembers(source: IrType, target: IrType): readonly IrType[] | null {
+  if (source.kind === "union") {
+    return source.types;
+  }
+  const isBoolean = source.kind === "keyword" && source.keyword === "boolean";
+  return isBoolean && target.kind === "union" ? BOOLEAN_MEMBERS : null;
+}
+
+/** The memoized check over the declarations of one generated file. */
+class AssignabilityCheck {
+  private readonly inProgress: PairResults = new Map();
+  private readonly results: PairResults = new Map();
+  private readonly typeKeyOf = createTypeKey();
+  private readonly resolution: TypeResolution;
+  /** How often a pair being compared was assumed related, and how deep the comparison is. */
+  private assumptions = 0;
+  private depth = 0;
+
+  constructor(lookup: DeclaredTypeLookup) {
+    this.resolution = new TypeResolution(lookup);
+  }
+
+  relate(source: IrType, target: IrType): Assignability {
+    const pair = {
+      source: this.resolution.resolved(source),
+      target: this.resolution.resolved(target),
+    };
+    if (
+      pair.source === pair.target ||
+      this.typeKeyOf(pair.source) === this.typeKeyOf(pair.target)
+    ) {
+      return "assignable";
+    }
+    const known = resultOf(this.results, pair.source, pair.target);
+    if (known !== undefined) {
+      return known;
+    }
+    // A pair being compared is assumed related, as the checker does for recursive types.
+    if (resultOf(this.inProgress, pair.source, pair.target) !== undefined) {
+      this.assumptions += 1;
+      return "assignable";
+    }
+    const assumedBefore = this.assumptions;
+    setResult(this.inProgress, pair, "assignable");
+    this.depth += 1;
+    const result = this.compare(pair.source, pair.target);
+    this.depth -= 1;
+    this.inProgress.get(pair.source)?.delete(pair.target);
+    // "Assignable" that rests on an assumption about an outer pair holds only if that pair does,
+    // so it is kept only once no outer pair is open. The assumption can only make a pair more
+    // related, so a rejection or an undecided pair reached under it is safe to keep.
+    if (result !== "assignable" || this.assumptions === assumedBefore || this.depth === 0) {
+      setResult(this.results, pair, result);
+    }
+    return result;
+  }
+
+  private compare(source: IrType, target: IrType): Assignability {
+    if (target.kind === "keyword" && target.keyword === "unknown") {
+      return "assignable";
+    }
+    if (source.kind === "keyword" && source.keyword === "never") {
+      return "assignable";
+    }
+    const sourceMembers = sourceUnionMembers(source, target);
+    if (sourceMembers !== null) {
+      return everyOf(sourceMembers, (member) => this.relate(member, target));
+    }
+    if (target.kind === "intersection") {
+      return everyOf(target.types, (member) => this.relateToIntersectionPart(source, member));
+    }
+    if (target.kind === "union") {
+      return this.relateToUnion(source, target);
+    }
+    if (source.kind === "intersection") {
+      // A part that fits is enough; the parts as one type are not modelled (see `merged`).
+      const fits = source.types.some((part) => this.relate(part, target) === "assignable");
+      return fits ? "assignable" : "undecided";
+    }
+    return this.compareSingle(source, target);
+  }
+
+  /**
+   * A part of an intersection the check cannot merge into one object. The checker skips the weak
+   * type check for such a part, so a rejection that may rest on it decides nothing.
+   */
+  private relateToIntersectionPart(source: IrType, part: IrType): Assignability {
+    const result = this.relate(source, part);
+    const from = this.resolution.resolved(source);
+    const to = this.resolution.resolved(part);
+    const isWeakRejection =
+      from.kind === "object" && to.kind === "object" && isWeakTypeRejected(from, to);
+    return result === "rejected" && isWeakRejection ? "undecided" : result;
+  }
+
+  /**
+   * An object may fit a union of objects that none of its members accepts alone, through a
+   * discriminant property (`{ k: "a" | "b" }` fits `{ k: "a" } | { k: "b" }`); not modelled.
+   */
+  private relateToUnion(source: IrType, target: IrUnionType): Assignability {
+    const result = someOf(target.types, (member) => this.relate(source, member));
+    const objectMembers = target.types.filter(
+      (member) => this.resolution.resolved(member).kind === "object",
+    );
+    const mayBeDiscriminated = source.kind === "object" && objectMembers.length > 1;
+    return result === "rejected" && mayBeDiscriminated ? "undecided" : result;
+  }
+
+  private compareSingle(source: IrType, target: IrType): Assignability {
+    const crossCategory = crossCategoryRelation(source, target);
+    if (crossCategory !== null) {
+      return crossCategory;
+    }
+    switch (source.kind) {
+      case "array":
+      case "tuple":
+      case "readonly":
+        return relateLists(source, target as IrListType, (from, to) => this.relate(from, to));
+      case "object":
+        return this.relateObjects(source, target as IrObjectType);
+      default:
+        return primitiveRelation(source, target);
+    }
+  }
+
+  private relateObjects(source: IrObjectType, target: IrObjectType): Assignability {
+    if (isWeakTypeRejected(source, target)) {
+      return "rejected";
+    }
+    const sourceProperties = propertiesOf(source);
+    const indexes = everyOf(indexSignaturesOf(target), (signature) =>
+      this.relateToIndex(source, signature),
+    );
+    if (indexes === "rejected") {
+      return indexes;
+    }
+    const properties = everyOf([...propertiesOf(target).values()], (property) =>
+      this.relateProperty(sourceProperties.get(nameOf(property)), property),
+    );
+    return everyOf([indexes, properties], (result) => result);
+  }
+
+  /**
+   * A string index signature of the target. A string index of the source is compared with it;
+   * without one, every property and index signature of the source is. An optional property is
+   * compared without the `undefined` its optionality adds, as the checker does.
+   */
+  private relateToIndex(source: IrObjectType, signature: IrIndexSignature): Assignability {
+    if (!isStringIndex(signature)) {
+      return "undecided";
+    }
+    const indexes = indexSignaturesOf(source);
+    const own = indexes.find(isStringIndex);
+    if (own !== undefined) {
+      return this.relate(own.type, signature.type);
+    }
+    const types = [
+      ...[...propertiesOf(source).values()].map((property) => property.type),
+      ...indexes.map((index) => index.type),
+    ];
+    return everyOf(types, (type) => this.relate(type, signature.type));
+  }
+
+  /**
+   * A property of the target. A missing optional one is not checked, not even against a string
+   * index of the source; a missing or optional source property fails a required one (TS2741).
+   */
+  private relateProperty(
+    source: IrPropertySignature | undefined,
+    target: IrPropertySignature,
+  ): Assignability {
+    if (source === undefined) {
+      return target.isOptional ? "assignable" : "rejected";
+    }
+    if (source.isOptional && !target.isOptional) {
+      return "rejected";
+    }
+    return this.relate(readType(source), readType(target));
+  }
+}
+
+/** What the check proves about a source type where a target is expected. */
+export type AssignabilityProof = (source: IrType, target: IrType) => Assignability;
+
+/** One memoized check, for all the comparisons of a `paths` type. */
+export function assignabilityProof(lookup: DeclaredTypeLookup): AssignabilityProof {
+  const check = new AssignabilityCheck(lookup);
+  return (source, target) => check.relate(source, target);
+}

package/src/application/transform/document/type-key.ts

@@ -0,0 +1,80 @@
+import { assertNever } from "../../../domain/assert-never.js";
+import type { IrMember, IrPropertyName, IrTupleElement, IrType } from "../../../domain/ir/nodes.js";
+
+/**
+ * A text that is the same for two types exactly when they are written the same, comments left
+ * out: the overlap check accepts a type it does not model when it is the same as the other.
+ */
+
+function nameKey(name: IrPropertyName): string {
+  return JSON.stringify(name.kind === "string" ? name.value : name.text);
+}
+
+function memberKey(member: IrMember, typeKeyOf: TypeKey): string {
+  if (member.kind === "indexSignature") {
+    const readonly = member.isReadonly ? "readonly " : "";
+    return `${readonly}[${typeKeyOf(member.parameterType)}]:${typeKeyOf(member.type)}`;
+  }
+  const readonly = member.isReadonly ? "readonly " : "";
+  const optional = member.isOptional ? "?" : "";
+  return `${readonly}${nameKey(member.name)}${optional}:${typeKeyOf(member.type)}`;
+}
+
+function listKey(types: readonly IrType[], typeKeyOf: TypeKey): string {
+  return types.map(typeKeyOf).join(",");
+}
+
+function elementKey(element: IrTupleElement, typeKeyOf: TypeKey): string {
+  const prefix = element.isRest ? "..." : "";
+  return `${prefix}${typeKeyOf(element.type)}${element.isOptional ? "?" : ""}`;
+}
+
+function computeKey(type: IrType, typeKeyOf: TypeKey): string {
+  switch (type.kind) {
+    case "keyword":
+      return type.keyword;
+    case "stringLiteral":
+      return JSON.stringify(type.value);
+    case "numberLiteral":
+    case "booleanLiteral":
+      return String(type.value);
+    case "reference":
+      return `${type.name}<${listKey(type.typeArguments, typeKeyOf)}>`;
+    case "array":
+      return `(${typeKeyOf(type.element)})[]`;
+    case "tuple":
+      return `[${type.elements.map((element) => elementKey(element, typeKeyOf)).join(",")}]`;
+    case "union":
+      return `union(${listKey(type.types, typeKeyOf)})`;
+    case "intersection":
+      return `intersection(${listKey(type.types, typeKeyOf)})`;
+    case "object":
+      return `{${type.members.map((member) => memberKey(member, typeKeyOf)).join(";")}}`;
+    case "indexedAccess":
+      return `${typeKeyOf(type.object)}[${typeKeyOf(type.index)}]`;
+    case "readonly":
+      return `readonly(${typeKeyOf(type.type)})`;
+    case "raw":
+      return `raw(${type.text})`;
+    default:
+      return assertNever(type);
+  }
+}
+
+/** The key of a type. */
+export type TypeKey = (type: IrType) => string;
+
+/** A key function that computes each node's key once; one per comparison, not shared. */
+export function createTypeKey(): TypeKey {
+  const keys = new WeakMap<IrType, string>();
+  const typeKeyOf: TypeKey = (type) => {
+    const known = keys.get(type);
+    if (known !== undefined) {
+      return known;
+    }
+    const key = computeKey(type, typeKeyOf);
+    keys.set(type, key);
+    return key;
+  };
+  return typeKeyOf;
+}