@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/RichText.d.mts

@@ -0,0 +1,84 @@
+import { f as MarkdownOrString } from "./scalar.mjs";
+
+//#region src/types/RichText.d.ts
+interface RichTextEmpty {
+  readonly isEmpty: true;
+  readonly isMarkdown: false;
+  readonly nonEmpty: false;
+  readonly $source: null;
+  readonly text: null;
+  readonly md: null;
+  readonly html: null;
+  equals(other: unknown): boolean;
+}
+interface RichTextNonEmpty {
+  readonly isEmpty: false;
+  readonly nonEmpty: true;
+  readonly isMarkdown: boolean;
+  readonly $source: MarkdownOrString;
+  readonly text: string;
+  readonly md: string;
+  readonly html: string;
+  equals(other: unknown): boolean;
+}
+type RichTextOrEmpty = RichTextNonEmpty | RichTextEmpty;
+/**
+ * RichText is a class that represents a potentially markdown string.
+ * It can be either a plain text or a markdown.
+ * It is used to represent the content of a node or a link.
+ */
+declare class RichText {
+  private static mdcache;
+  private static txtcache;
+  private static getOrCreateFromText;
+  private static getOrCreateFromMarkdown;
+  /**
+   * Creates and memoizes a RichText instance.
+   * @see ElementModel.description
+   * @example
+   *
+   *  get description(): RichTextOrEmpty {
+   *    return RichText.memoize(this, 'description', this.$element.description)
+   *  }
+   */
+  static memoize(obj: object, tag: symbol | string, source: MarkdownOrString | null | undefined): RichTextOrEmpty;
+  /**
+   * Creates a RichText instance from a source.
+   */
+  static from(source: RichTextOrEmpty | MarkdownOrString | string | null | undefined): RichTextOrEmpty;
+  /**
+   * This is a workaround for the fact that we need instance of RichText for `instanceof` checks
+   * It is invalid inheritance (returning `null` from getters), and we cast to @see RichTextEmpty
+   */
+  static EMPTY: RichTextEmpty;
+  readonly $source: Readonly<MarkdownOrString> | null;
+  readonly isEmpty: boolean;
+  readonly nonEmpty: boolean;
+  readonly isMarkdown: boolean;
+  /**
+   * Private constructor to prevent direct instantiation.
+   * Use {@link RichText.from} or {@link RichText.memoize} instead.
+   */
+  private constructor();
+  /**
+   * Returns the text content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the markdown.
+   */
+  get text(): string;
+  /**
+   * Returns the markdown content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the markdown.
+   */
+  get md(): string;
+  /**
+   * Returns the html content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the HTML.
+   */
+  get html(): string;
+  equals(other: unknown): boolean;
+}
+//#endregion
+export { RichTextOrEmpty as i, RichTextEmpty as n, RichTextNonEmpty as r, RichText as t };

package/dist/_chunks/RichText.mjs

@@ -0,0 +1,148 @@
+import { h as memoizeProp, n as markdownToHtml, t as markdownToText } from "./utils.mjs";
+import { r as nonexhaustive } from "./invariant.mjs";
+import { a as import_lru_map } from "./libs/mnemonist.mjs";
+
+//#region src/types/RichText.ts
+const symb_text = Symbol.for("text");
+const symb_html = Symbol.for("html");
+const emptyTxt = "";
+/**
+* RichText is a class that represents a potentially markdown string.
+* It can be either a plain text or a markdown.
+* It is used to represent the content of a node or a link.
+*/
+var RichText = class RichText {
+	static mdcache = new import_lru_map.default(500);
+	static txtcache = new import_lru_map.default(500);
+	static getOrCreateFromText(txt) {
+		txt = txt.trimEnd();
+		if (txt === emptyTxt) return RichText.EMPTY;
+		let cached = RichText.txtcache.get(txt);
+		if (cached) return cached;
+		cached = new RichText({ txt });
+		RichText.txtcache.set(txt, cached);
+		return cached;
+	}
+	static getOrCreateFromMarkdown(md) {
+		md = md.trimEnd();
+		if (md === emptyTxt) return RichText.EMPTY;
+		let cached = RichText.mdcache.get(md);
+		if (cached) return cached;
+		cached = new RichText({ md });
+		RichText.mdcache.set(md, cached);
+		return cached;
+	}
+	/**
+	* Creates and memoizes a RichText instance.
+	* @see ElementModel.description
+	* @example
+	*
+	*  get description(): RichTextOrEmpty {
+	*    return RichText.memoize(this, 'description', this.$element.description)
+	*  }
+	*/
+	static memoize(obj, tag, source) {
+		return memoizeProp(obj, tag, () => RichText.from(source));
+	}
+	/**
+	* Creates a RichText instance from a source.
+	*/
+	static from(source) {
+		if (source === null || source === void 0 || source === RichText.EMPTY) return RichText.EMPTY;
+		if (source instanceof RichText) return source;
+		if (typeof source === "string") return this.getOrCreateFromText(source);
+		if ("isEmpty" in source && source.isEmpty) return RichText.EMPTY;
+		if ("md" in source) return this.getOrCreateFromMarkdown(source.md);
+		return this.getOrCreateFromText(source.txt);
+	}
+	/**
+	* This is a workaround for the fact that we need instance of RichText for `instanceof` checks
+	* It is invalid inheritance (returning `null` from getters), and we cast to @see RichTextEmpty
+	*/
+	static EMPTY = new class extends RichText {
+		isEmpty = true;
+		nonEmpty = false;
+		isMarkdown = false;
+		$source = null;
+		constructor() {
+			super({ txt: emptyTxt });
+		}
+		get text() {
+			return null;
+		}
+		get md() {
+			return null;
+		}
+		get html() {
+			return null;
+		}
+	}();
+	$source;
+	isEmpty;
+	nonEmpty;
+	isMarkdown;
+	/**
+	* Private constructor to prevent direct instantiation.
+	* Use {@link RichText.from} or {@link RichText.memoize} instead.
+	*/
+	constructor(source) {
+		this.isMarkdown = false;
+		if (typeof source === "string") {
+			this.$source = { txt: source };
+			this.isEmpty = source.trim() === emptyTxt;
+		} else {
+			this.$source = source;
+			this.isEmpty = true;
+			if ("md" in source) {
+				this.isEmpty = source.md === emptyTxt;
+				this.isMarkdown = true;
+			} else this.isEmpty = source.txt === emptyTxt;
+		}
+		this.nonEmpty = !this.isEmpty;
+	}
+	/**
+	* Returns the text content of the rich text.
+	* If the source is a string, it returns the string.
+	* If the source is a markdown, it returns the markdown.
+	*/
+	get text() {
+		if (this.isEmpty || this.$source === null) return emptyTxt;
+		const source = this.$source;
+		if ("txt" in source) return source.txt;
+		return memoizeProp(this, symb_text, () => markdownToText(source.md));
+	}
+	/**
+	* Returns the markdown content of the rich text.
+	* If the source is a string, it returns the string.
+	* If the source is a markdown, it returns the markdown.
+	*/
+	get md() {
+		if (this.isEmpty || this.$source === null) return emptyTxt;
+		const source = this.$source;
+		if ("md" in source) return source.md;
+		if ("txt" in source) return source.txt;
+		nonexhaustive(source);
+	}
+	/**
+	* Returns the html content of the rich text.
+	* If the source is a string, it returns the string.
+	* If the source is a markdown, it returns the HTML.
+	*/
+	get html() {
+		if (this.isEmpty || this.$source === null) return emptyTxt;
+		const source = this.$source;
+		if ("txt" in source) return source.txt;
+		return memoizeProp(this, symb_html, () => markdownToHtml(source.md));
+	}
+	equals(other) {
+		if (this === other) return true;
+		if (!(other instanceof RichText)) return false;
+		if (this.isEmpty && other.isEmpty) return true;
+		if (this.isEmpty !== other.isEmpty || this.isMarkdown !== other.isMarkdown) return false;
+		if (this.isMarkdown) return this.$source?.md === other.$source?.md;
+		return this.$source?.txt === other.$source?.txt;
+	}
+};
+
+//#endregion
+export { RichText as t };

package/dist/_chunks/_aux.d.mts

@@ -0,0 +1,289 @@
+import { C as ViewId$1, S as Tag$1, a as EdgeId$1, f as MarkdownOrString, g as RelationId$1, h as ProjectId$1, i as DeploymentKind$1, o as ElementKind$1, p as NodeId$1, r as DeploymentFqn$1, s as Fqn$1, v as RelationshipKind } from "./scalar.mjs";
+import { IfNever, IsAny, IsLiteral, IsNever, KeysOfUnion, Simplify, UnionToIntersection } from "type-fest";
+
+//#region src/types/_common.d.ts
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+type ReorderedArray<T extends IterableContainer> = { -readonly [P in keyof T]: T[number] };
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever<Expressions> = UnionToIntersection<{ [Name in keyof Expressions]: { -readonly [Key in keyof Expressions[Name]]?: never } }[keyof Expressions]>;
+/**
+ * @example
+ * ```ts
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   // Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ * ```
+ */
+type ExclusiveUnion<Expressions, All = AllNever<Expressions>> = Expressions extends object ? { [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]> }[keyof Expressions] : never;
+/**
+ * Copy from https://github.com/remeda/remeda/blob/main/packages/remeda/src/internal/types/NTuple.ts
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn, unknown>;
+type Predicate<T> = (x: T) => boolean;
+interface Link {
+  title?: string;
+  url: string;
+  relative?: string;
+}
+/**
+ * Coalesce `V` to a string if it is `any`
+ */
+type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
+type ExactObject<T, InputType = unknown> = { [KeyType in keyof T]: undefined extends T[KeyType] ? T[KeyType] | undefined : T[KeyType] } & Record<Exclude<keyof InputType, KeysOfUnion<T>>, never>;
+/**
+ * Allows only exact properties of `U` to be present in `T` and omits undefined values
+ *
+ * See {@link Exact} for more details (this version is non-deep)
+ */
+declare function exact<Expected, T extends ExactObject<Expected, T>>(a: T): Expected;
+//#endregion
+//#region src/types/const.d.ts
+/**
+ * Determines the stage of the model:
+ * 1. `parsed` - parsed from DSL or returned from Builder
+ * 2. `computed` - views are computed
+ * 3. `layouted` - views are layouted
+ *
+ * @internal
+ */
+type ModelStage = 'parsed' | 'computed' | 'layouted';
+type ExtractOnStage<T, S extends ModelStage> = Extract<T, {
+  [_stage]: S;
+}>;
+declare function isOnStage<T extends {
+  [_stage]: ModelStage;
+}, S extends ModelStage>(value: T, stage: S): value is ExtractOnStage<T, S>;
+/**
+ * Property name to store the stage of the model
+ *
+ * @internal
+ */
+declare const _stage = "_stage";
+type _stage = typeof _stage;
+/**
+ * Property name to store type information, used to identify the type of the view
+ *
+ * @internal
+ */
+declare const _type = "_type";
+type _type = typeof _type;
+/**
+ * Property name to store layout type information, used to identify the type of the layout*
+ * @internal
+ */
+declare const _layout = "_layout";
+type _layout = typeof _layout;
+declare namespace _aux_d_exports {
+  export { AllKinds, Any, Any as AnyAux, AnyComputed, AnyLayouted, AnyOnStage, AnyParsed, AnySpec, Aux, DeploymentFqn, DeploymentId, DeploymentKind, EdgeId, ElementId, ElementKind, Fqn, LooseDeploymentId, LooseDeploymentKind, LooseElementId, LooseElementKind, LooseLiteral, LooseRelationKind, LooseTag, LooseTags, LooseViewId, Metadata, MetadataKey, Never, NodeId, OrString, PickByStage, ProjectId, RelationId, RelationKind, Spec, SpecAux, Stage, DeploymentFqn as StrictDeploymentFqn, StrictDeploymentKind, StrictElementKind, Fqn as StrictFqn, StrictProjectId, StrictRelationKind, StrictTag, StrictViewId, Tag, Tags, Unknown, UnknownComputed, UnknownLayouted, UnknownParsed, ViewId, WithDescriptionAndTech, WithLinks, WithMetadata, WithNotation, WithOptionalLinks, WithOptionalTags, WithTags, preferDescription, preferSummary, setProject, setStage, toComputed, toLayouted, toParsed };
+}
+/**
+ * Specification types (kinds, tags, metadata keys)
+ *
+ * @param ElementKind - Literal union of element kinds
+ * @param DeploymentKind - Literal union of deployment kinds
+ * @param RelationKind - Literal union of relationship kinds
+ * @param Tag - Literal union of tags
+ * @param MetadataKey - Literal union of metadata keys
+ */
+interface SpecAux<ElementKind extends string, DeploymentKind extends string, RelationKind extends string, Tag extends string, MetadataKey extends string> {
+  ElementKind: ElementKind;
+  DeploymentKind: DeploymentKind;
+  RelationKind: RelationKind;
+  Tag: Tag;
+  MetadataKey: MetadataKey;
+}
+type AnySpec = SpecAux<any, any, any, any, any>;
+/**
+ * Auxilary interface to keep inferred types
+ *
+ * @typeParam Stage - View stage
+ * @typeParam Element - Literal union of FQNs of model elements
+ * @typeParam Deployment - Literal union of FQNs of deployment elements
+ * @typeParam View - Literal union of view identifiers
+ * @typeParam Project - Project identifier type
+ * @typeParam Spec - Specification types (kinds, tags, metadata keys)
+ */
+interface Aux<Stage extends ModelStage, Element extends string, Deployment extends string, View extends string, Project extends string, Spec extends AnySpec> {
+  Stage: Stage;
+  ProjectId: Project;
+  ElementId: Element;
+  DeploymentId: Deployment;
+  ViewId: View;
+  ElementKind: Spec['ElementKind'];
+  DeploymentKind: Spec['DeploymentKind'];
+  RelationKind: Spec['RelationKind'];
+  Tag: Spec['Tag'];
+  MetadataKey: Spec['MetadataKey'];
+}
+type AnyOnStage<Stage extends ModelStage> = Aux<Stage, any, any, any, any, any>;
+type AnyParsed = AnyOnStage<'parsed'>;
+type AnyComputed = AnyOnStage<'computed'>;
+type AnyLayouted = AnyOnStage<'layouted'>;
+type Any = Aux<any, any, any, any, any, any>;
+type Never = Aux<never, never, never, never, never, SpecAux<never, never, never, never, never>>;
+/**
+ * Fallback when {@link Aux} can't be inferred.
+ * By default assumes non parsed model
+ */
+type Unknown = UnknownComputed | UnknownLayouted;
+type UnknownParsed = Aux<'parsed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownComputed = Aux<'computed', string, string, string, string, SpecAux<string, string, string, string, string>>;
+type UnknownLayouted = Aux<'layouted', string, string, string, string, SpecAux<string, string, string, string, string>>;
+/**
+ * Reads stage from Aux
+ */
+type Stage<A> = A extends Aux<infer S, any, any, any, any, any> ? IfNever<S, never, Coalesce<S, ModelStage>> : never;
+/**
+ * Picks type based on stage from Aux
+ */
+type PickByStage<A extends Any, OnParsed, OnComputed, OnLayouted = OnComputed> = {
+  parsed: OnParsed;
+  computed: OnComputed;
+  layouted: OnLayouted;
+}[A['Stage']];
+type setStage<A, S extends ModelStage> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
+type toParsed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'parsed', E, D, V, P, Spec> : never;
+type toComputed<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'computed', E, D, V, P, Spec> : never;
+type toLayouted<A> = A extends Aux<any, infer E, infer D, infer V, infer P, infer Spec> ? Aux<'layouted', E, D, V, P, Spec> : never;
+/**
+ * Project identifier from Aux
+ */
+type ProjectId<A> = A extends Aux<any, any, any, any, infer P, any> ? Coalesce<P> : never;
+type setProject<A, P extends string> = A extends Aux<infer S, infer E, infer D, infer V, any, infer Spec> ? Aux<S, E, D, V, P, Spec> : never;
+/**
+ * Element FQN from Aux as branded type
+ */
+type Fqn<A> = A extends Any ? Fqn$1<ElementId<A>> : never;
+/**
+ * Element FQN from Aux as a literal union
+ */
+type ElementId<A> = A extends Any ? Coalesce<A['ElementId']> : never;
+/**
+ * Deployment FQN from Aux as branded type
+ */
+type DeploymentFqn<A> = A extends Any ? DeploymentFqn$1<DeploymentId<A>> : never;
+/**
+ * Deployment FQN from Aux as a literal union
+ * @alias {@link DeploymentFqn}
+ */
+type DeploymentId<A> = A extends Any ? Coalesce<A['DeploymentId']> : never;
+/**
+ * View identifier from Aux as a literal union
+ */
+type ViewId<A> = A extends Any ? Coalesce<A['ViewId']> : never;
+type RelationId = RelationId$1;
+type NodeId = NodeId$1;
+type EdgeId = EdgeId$1;
+/**
+ * ElementKind from Aux as a literal union
+ */
+type ElementKind<A> = A extends Any ? Coalesce<A['ElementKind']> : never;
+/**
+ * DeploymentKind from Aux as a literal union
+ */
+type DeploymentKind<A> = A extends Any ? Coalesce<A['DeploymentKind']> : never;
+/**
+ * RelationKind from Aux as a literal union
+ */
+type RelationKind<A> = A extends Any ? Coalesce<A['RelationKind']> : never;
+/**
+ * Tags from Aux as a literal union
+ */
+type Tag<A> = A extends Any ? Coalesce<A['Tag']> : never;
+/**
+ * Array of tags from Aux
+ */
+type Tags<A extends Any> = readonly Tag<A>[];
+/**
+ * Metadata key from Aux
+ */
+type MetadataKey<A> = A extends Any ? Coalesce<A['MetadataKey']> : never;
+/**
+ * Metadata object from Aux
+ */
+type Metadata<A extends Any> = IsNever<A['MetadataKey']> extends true ? never : IsLiteral<A['MetadataKey']> extends true ? { [key in A['MetadataKey']]?: string | string[] } : Record<string, string | string[]>;
+/**
+ * All known kinds from Aux as a literal union.
+ */
+type AllKinds<A> = ElementKind<A> | DeploymentKind<A> | RelationKind<A>;
+/**
+ * Specification from Aux
+ */
+type Spec<A> = A extends Aux<any, any, any, any, any, SpecAux<infer E, infer D, infer R, infer T, infer M>> ? SpecAux<E, D, R, T, M> : never;
+type StrictProjectId<A> = A extends infer T extends Any ? ProjectId$1<ProjectId<T>> : never;
+type StrictViewId<A> = A extends infer T extends Any ? ViewId$1<ViewId<T>> : never;
+type StrictTag<A> = A extends infer T extends Any ? Tag$1<Tag<T>> : never;
+type StrictElementKind<A> = A extends infer T extends Any ? ElementKind$1<ElementKind<T>> : never;
+type StrictDeploymentKind<A> = A extends infer T extends Any ? DeploymentKind$1<DeploymentKind<T>> : never;
+type StrictRelationKind<A> = A extends infer T extends Any ? RelationshipKind<RelationKind<T>> : never;
+type WithDescriptionAndTech = {
+  readonly summary?: MarkdownOrString | null;
+  readonly description?: MarkdownOrString | null;
+  readonly technology?: string | null;
+};
+/**
+ * Returns summary if it is not null, otherwise returns description
+ */
+declare function preferSummary(a: WithDescriptionAndTech): MarkdownOrString | null | undefined;
+/**
+ * Returns description if it is not null, otherwise returns summary
+ */
+declare function preferDescription(a: WithDescriptionAndTech): MarkdownOrString | null | undefined;
+type WithTags<A extends Any> = {
+  readonly tags: Tags<A>;
+};
+type WithOptionalTags<A extends Any> = {
+  readonly tags?: Tags<A> | null;
+};
+type WithLinks = {
+  readonly links: readonly Link[];
+};
+type WithOptionalLinks = {
+  readonly links?: readonly Link[] | null;
+};
+type WithMetadata<A extends Any> = {
+  readonly metadata?: Metadata<A>;
+};
+type WithNotation = {
+  readonly notation?: string | null;
+};
+/**
+ * @see {@link LiteralUnion} from type-fest (https://github.com/sindresorhus/type-fest/blob/main/source/literal-union.d.ts)
+ */
+type OrString = string & Record<never, never>;
+/**
+ * Allows any string value, but still auto-completes to the possible values in IDE
+ */
+type LooseLiteral<V extends string> = Coalesce<V> | OrString;
+type LooseElementId<A> = A extends Any ? LooseLiteral<A['ElementId']> : string;
+type LooseDeploymentId<A> = A extends Any ? LooseLiteral<A['DeploymentId']> : string;
+type LooseViewId<A> = A extends Any ? LooseLiteral<A['ViewId']> : string;
+type LooseTag<A> = A extends Any ? LooseLiteral<A['Tag']> : string;
+type LooseTags<A> = A extends Any ? readonly (LooseLiteral<A['Tag']>)[] : string[];
+type LooseElementKind<A> = A extends Any ? LooseLiteral<A['ElementKind']> : string;
+type LooseDeploymentKind<A> = A extends Any ? LooseLiteral<A['DeploymentKind']> : string;
+type LooseRelationKind<A> = A extends Any ? LooseLiteral<A['RelationKind']> : string;
+//#endregion
+export { WithNotation as $, PickByStage as A, StrictRelationKind as B, LooseTags as C, NTuple as Ct, Never as D, ReorderedArray as Dt, MetadataKey as E, Predicate as Et, SpecAux as F, Unknown as G, StrictViewId as H, Stage as I, UnknownParsed as J, UnknownComputed as K, StrictDeploymentKind as L, RelationId as M, RelationKind as N, NodeId as O, exact as Ot, Spec as P, WithMetadata as Q, StrictElementKind as R, LooseTag as S, Link as St, Metadata as T, NonEmptyReadonlyArray as Tt, Tag as U, StrictTag as V, Tags as W, WithDescriptionAndTech as X, ViewId as Y, WithLinks as Z, LooseDeploymentKind as _, Coalesce as _t, AnyOnStage as a, preferSummary as at, LooseLiteral as b, IteratorLike as bt, Aux as c, toComputed as ct, DeploymentKind as d, ExtractOnStage as dt, WithOptionalLinks as et, EdgeId as f, ModelStage as ft, LooseDeploymentId as g, isOnStage as gt, Fqn as h, _type as ht, AnyLayouted as i, preferDescription as it, ProjectId as j, OrString as k, DeploymentFqn as l, toLayouted as lt, ElementKind as m, _stage as mt, Any as n, WithTags as nt, AnyParsed as o, setProject as ot, ElementId as p, _layout as pt, UnknownLayouted as q, AnyComputed as r, _aux_d_exports as rt, AnySpec as s, setStage as st, AllKinds as t, WithOptionalTags as tt, DeploymentId as u, toParsed as ut, LooseElementId as v, ExclusiveUnion as vt, LooseViewId as w, NonEmptyArray as wt, LooseRelationKind as x, KeysOf as xt, LooseElementKind as y, IterableContainer as yt, StrictProjectId as z };

package/dist/_chunks/_aux.mjs

@@ -0,0 +1,18 @@
+//#region src/types/_aux.ts
+/**
+* Returns summary if it is not null, otherwise returns description
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function preferSummary(a) {
+	return a.summary ?? a.description;
+}
+/**
+* Returns description if it is not null, otherwise returns summary
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function preferDescription(a) {
+	return a.description ?? a.summary;
+}
+
+//#endregion
+export { preferSummary as n, preferDescription as t };