@erudit-js/prose 4.1.0 → 4.2.0-dev.1

package/dist/snippet.js

@@ -1,86 +1,152 @@
-import { ProseError } from "@jsprose/core";
-import { defineResolveStep } from "./resolveStep.js";
-export function finalizeSnippet(processTagArgs) {
-	const finalSnippet = {};
-	const propsSnippet = processTagArgs.props.snippet;
-	const builtinSnippet = processTagArgs.element.snippet;
-	//
-	const quick = propsSnippet?.quick ?? builtinSnippet?.quick;
-	if (quick) {
-		finalSnippet.quick = quick;
+import { EruditProseError } from "./error.js";
+import { defineRawToProseHook } from "./rawToProse/hook.js";
+export const NO_SNIPPET_PREFIX = "__ERDUIT_tagNoSnippet";
+export function finalizeSnippet(rawElement, snippetTagProp) {
+	if (snippetTagProp) {
+		// Explicitly add snippet using tag prop data
+		const normalizedSnippet = normalizeSnippet(snippetTagProp, rawElement.snippet?.title, rawElement.title);
+		const tagPropHadExplicitSeo = snippetTagProp.seo !== undefined;
+		if (rawElement.snippet) {
+			const normalizedInternalSnippet = normalizeSnippet(rawElement.snippet, rawElement.title);
+			// Merge internal snippet data as fallback for missing values in tag prop snippet
+			if (!normalizedSnippet.description && normalizedInternalSnippet.description) {
+				normalizedSnippet.description = normalizedInternalSnippet.description;
+			}
+			if (normalizedSnippet.search === undefined && normalizedInternalSnippet.search) {
+				normalizedSnippet.search = normalizedInternalSnippet.search;
+			}
+			if (normalizedSnippet.key === undefined && normalizedInternalSnippet.key) {
+				normalizedSnippet.key = normalizedInternalSnippet.key;
+			}
+			if (normalizedSnippet.seo === undefined && normalizedInternalSnippet.seo) {
+				normalizedSnippet.seo = normalizedInternalSnippet.seo;
+			}
+		}
+		// Add snippet to SEO if either search or key is enabled unless SEO was explicitly set in the tag prop
+		if (!tagPropHadExplicitSeo && normalizedSnippet.seo !== false && (normalizedSnippet.search || normalizedSnippet.key)) {
+			normalizedSnippet.seo = true;
+		}
+		// Prune snippet if it has no active features
+		if (!normalizedSnippet.search && !normalizedSnippet.key && !normalizedSnippet.seo) {
+			delete rawElement.snippet;
+			return;
+		}
+		rawElement.snippet = normalizedSnippet;
+		return;
 	}
-	//
-	const search = propsSnippet?.search ?? builtinSnippet?.search;
-	if (search) {
-		finalSnippet.search = search;
+	if (rawElement.snippet) {
+		// This snippet was supposed to be used to merge data but not needed anymore because tag prop snippet is not provided
+		delete rawElement.snippet;
+		return;
+	}
+}
+export function normalizeSnippet(snippet, ...fallbackTitles) {
+	const title = snippet.title?.trim() || fallbackTitles.map((t) => t?.trim()).find(Boolean);
+	if (!title) {
+		throw new EruditProseError("Unable to retrieve non-empty title for snippet!");
 	}
-	//
-	let seo = propsSnippet?.seo ?? builtinSnippet?.seo;
-	// If none of the flags are set to true, no snippet is created
-	if (!quick && !search && !seo) {
+	const description = snippet.description?.trim() || undefined;
+	const result = {
+		...snippet,
+		title,
+		description
+	};
+	return result;
+}
+export function toSearchSnippet(snippet) {
+	if (!snippet || !snippet.search) {
 		return undefined;
 	}
-	// Enable SEO if either quick or search is enabled unless SEO is explicitly disabled
-	// Check both element defaults and props - if either explicitly disables seo, don't auto-enable
-	const seoExplicitlyDisabled = builtinSnippet?.seo === false || propsSnippet?.seo === false;
-	if (!seo) {
-		if (!seoExplicitlyDisabled) {
-			if (quick || search) {
-				seo = true;
-			}
-		}
+	if (snippet.search === true) {
+		return {
+			title: snippet.title,
+			description: snippet.description
+		};
 	}
-	if (seo) {
-		finalSnippet.seo = seo;
+	if (typeof snippet.search === "string") {
+		const title = snippet.search.trim() || snippet.title;
+		return {
+			title,
+			description: snippet.description
+		};
 	}
-	//
-	const title = getGenericTitle(processTagArgs);
-	if (title) {
-		finalSnippet.title = title;
+	if (Array.isArray(snippet.search)) {
+		const synonyms = snippet.search.map((synonym) => synonym.trim()).filter(Boolean);
+		return {
+			title: snippet.title,
+			description: snippet.description,
+			synonyms: synonyms.length > 0 ? synonyms : undefined
+		};
 	}
-	const description = getGenericDescription(processTagArgs);
-	if (description) {
-		finalSnippet.description = description;
+	const title = snippet.search.title?.trim() || snippet.title;
+	const description = snippet.search.description?.trim() || snippet.description;
+	const synonyms = snippet.search.synonyms?.map((synonym) => synonym.trim()).filter(Boolean);
+	return {
+		title,
+		description,
+		synonyms: synonyms && synonyms.length > 0 ? synonyms : undefined
+	};
+}
+export function toKeySnippet(snippet) {
+	if (!snippet || !snippet.key) {
+		return undefined;
 	}
-	//
-	if (!finalSnippet.title) {
-		let titlessFlags = [];
-		if (quick && typeof quick !== "string") {
-			if (quick === true || !quick.title) {
-				titlessFlags.push("quick");
-			}
-		}
-		if (search && typeof search !== "string") {
-			if (search === true || Array.isArray(search) || !search.title) {
-				titlessFlags.push("search");
-			}
-		}
-		if (seo && typeof seo !== "string") {
-			if (seo === true || !seo.title) {
-				titlessFlags.push("seo");
-			}
-		}
-		throw new ProseError(`Unable to get title for snippet flags (${titlessFlags.join(", ")}) because no explicit, general inherited title was provided!`);
+	if (snippet.key === true) {
+		return {
+			title: snippet.title,
+			description: snippet.description
+		};
 	}
-	//
-	processTagArgs.element.snippet = finalSnippet;
-	return finalSnippet;
-}
-function getGenericTitle(processTagArgs) {
-	const title = processTagArgs.props.snippet?.title?.trim() || processTagArgs.element.snippet?.title?.trim() || processTagArgs.element.title?.trim();
-	return title;
-}
-function getGenericDescription(processTagArgs) {
-	return processTagArgs.props.snippet?.description?.trim() || processTagArgs.element.snippet?.description?.trim();
+	if (typeof snippet.key === "string") {
+		const title = snippet.key.trim() || snippet.title;
+		return {
+			title,
+			description: snippet.description
+		};
+	}
+	const title = snippet.key.title?.trim() || snippet.title;
+	const description = snippet.key.description?.trim() || snippet.description;
+	return {
+		title,
+		description
+	};
 }
-export const snippetStep = defineResolveStep(({ rawElement, proseElement }) => {
-	if (rawElement.snippet && proseElement.id) {
-		const resolvedSnippet = {
-			schemaName: rawElement.schemaName,
-			isUnique: Boolean(rawElement.uniqueName),
-			elementId: proseElement.id,
-			snippetData: rawElement.snippet
+export function toSeoSnippet(snippet) {
+	if (!snippet || !snippet.seo) {
+		return undefined;
+	}
+	if (snippet.seo === true) {
+		return {
+			title: snippet.title,
+			description: snippet.description
+		};
+	}
+	if (typeof snippet.seo === "string") {
+		const title = snippet.seo.trim() || snippet.title;
+		return {
+			title,
+			description: snippet.description
 		};
-		return resolvedSnippet;
 	}
+	const title = snippet.seo.title?.trim() || snippet.title;
+	const description = snippet.seo.description?.trim() || snippet.description;
+	return {
+		title,
+		description
+	};
+}
+export const snippetHook = defineRawToProseHook(({ task: context, result }) => {
+	if (!context.snippets?.enabled) {
+		return;
+	}
+	return { step: ({ rawElement, proseElement }) => {
+		if (rawElement.snippet && proseElement.id) {
+			const resolvedSnippet = {
+				schemaName: rawElement.schema.name,
+				elementId: proseElement.id,
+				snippet: rawElement.snippet
+			};
+			result.snippets.push(resolvedSnippet);
+		}
+	} };
 });

package/dist/tag.d.ts

@@ -1,22 +1,25 @@
-import { Registry, type AnySchema, type ConfigurableTagProps, type NormalizedChildren, type ProcessTagFunction, type TagDefinition } from '@jsprose/core';
-import type { EruditRawElement } from './rawElement.js';
-import { type ObjPropSnippet } from './snippet.js';
-import { type ObjPropToc } from './toc.js';
-declare const NoTocSymbol: unique symbol;
-declare const NoSnippetSymbol: unique symbol;
-export type NoToc = {
-    readonly [NoTocSymbol]?: never;
-};
-export type NoSnippet = {
-    readonly [NoSnippetSymbol]?: never;
-};
-export type EruditTagProps<TProps extends Record<string, unknown>> = (TProps extends NoToc ? {} : ObjPropToc) & (TProps extends NoSnippet ? {} : ObjPropSnippet);
-export type EruditProcessTagArgs = {
-    tagName: string;
-    element: EruditRawElement<AnySchema>;
-    props: ConfigurableTagProps & ObjPropSnippet & ObjPropToc;
+import { TAG_PREFIX, type NormalizedChildren, type Schema, type TagProps, type ValidateTagCustomProps } from 'tsprose';
+import type { ToEruditRawElement } from './rawElement.js';
+import { NO_SNIPPET_PREFIX, type NoSnippet, type SnippetTagProp } from './snippet.js';
+import { NO_TOC_PREFIX, type NoToc, type TocTagProp } from './toc.js';
+type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+export type ToEruditTag<TSchema extends Schema, TagName extends string, Props extends Record<string, any> = {}> = {
+    [TAG_PREFIX]: true;
+    tagName: TagName;
+    schema: TSchema;
+} & ((props: DistributiveOmit<EruditTagProps<TSchema, TagName, Props>, typeof NO_TOC_PREFIX | typeof NO_SNIPPET_PREFIX>) => ToEruditRawElement<TSchema, TagName>);
+export type EruditTag = ToEruditTag<Schema, string, any>;
+export type EruditTagProps<TSchema extends Schema, TagName extends string, Props extends Record<string, any> = {}> = TagProps<TSchema, TagName, Props> & EruditTagTocSnippet<TSchema, Props>;
+export type EruditTagTocSnippet<TSchema extends Schema, Props extends Record<string, any> = {}> = TSchema['linkable'] extends false ? {} : (Props extends NoToc ? {} : TocTagProp) & (Props extends NoSnippet ? {} : SnippetTagProp);
+export declare function defineEruditTag<TSchema extends Schema, TagName extends string>(tagParameters: {
+    tagName: TagName;
+    schema: TSchema;
+}): <const Props extends ValidateTagCustomProps<Props>>(eruditTagElementHandler: EruditTagElementHandler<TagName, TSchema, Props>) => ToEruditTag<TSchema, TagName, Props>;
+export type EruditTagElementHandlerContext<TagName extends string = string, TSchema extends Schema = Schema, Props extends Record<string, any> = {}> = {
+    tagName: TagName;
+    props: EruditTagProps<TSchema, TagName, Props>;
     children: NormalizedChildren;
-    registry: Registry;
+    element: ToEruditRawElement<TSchema, TagName>;
 };
-export declare function defineEruditTag<const TSchema extends AnySchema, const TTagDefinition extends TagDefinition<TSchema>>(definition: TTagDefinition): <const TConfigurableTagProps extends ConfigurableTagProps>(processTag: ProcessTagFunction<TTagDefinition["schema"], TTagDefinition, TConfigurableTagProps & (TTagDefinition["schema"]["linkable"] extends true ? EruditTagProps<TConfigurableTagProps> : {}), EruditRawElement<TTagDefinition["schema"], TTagDefinition["tagName"]>>) => import("@jsprose/core").Tag<TTagDefinition["tagName"], TTagDefinition["schema"], TConfigurableTagProps & (TTagDefinition["schema"]["linkable"] extends true ? EruditTagProps<TConfigurableTagProps> : {})>;
+export type EruditTagElementHandler<TagName extends string, TSchema extends Schema, Props extends Record<string, any>> = (context: EruditTagElementHandlerContext<TagName, TSchema, Props>) => void;
 export {};

package/dist/tag.js

@@ -1,18 +1,22 @@
-import { defineTag, Registry } from "@jsprose/core";
-import { finalizeSnippet } from "./snippet.js";
-import { finalizeToc } from "./toc.js";
-import { finalizeTitle } from "./title.js";
-export function defineEruditTag(definition) {
-	const baseFinalizeTag = defineTag(definition);
-	function eruditFinalizeTag(processTag) {
-		const eruditTag = baseFinalizeTag((args) => {
-			processTag(args);
-			// Use every possibility to get shared title property
-			args.element.title = finalizeTitle(args);
-			args.element.snippet = finalizeSnippet(args);
-			args.element.toc = finalizeToc(args);
-			// Use every possibility to get human-readable slug whether it is set manually or taken from snippet or toc
-			args.element.slug ||= args.element.snippet?.title || args.element.toc?.title || args.element.title;
+import { defineTag, TAG_PREFIX } from "tsprose";
+import { finalizeSnippet, NO_SNIPPET_PREFIX } from "./snippet.js";
+import { finalizeToc, NO_TOC_PREFIX } from "./toc.js";
+export function defineEruditTag(tagParameters) {
+	const baseFinalizeTag = defineTag(tagParameters);
+	function eruditFinalizeTag(eruditTagElementHandler) {
+		const eruditTag = baseFinalizeTag((baseContext) => {
+			const specificContext = baseContext;
+			const anyContext = baseContext;
+			// Allow specific tag to set title, snippet and toc properties first
+			// Then used it for finalization processes
+			eruditTagElementHandler(specificContext);
+			const rawElement = anyContext.element;
+			finalizeSnippet(rawElement, anyContext.props.snippet);
+			finalizeToc(rawElement, anyContext.props.toc);
+			// Preserve title
+			rawElement.title ||= anyContext.props.snippet?.title?.trim() || (typeof rawElement.toc === "string" ? rawElement.toc : undefined);
+			// Use every possibility to get human-readable slug
+			rawElement.slug ||= rawElement.title;
 		});
 		return eruditTag;
 	}

package/dist/toc.d.ts

@@ -1,18 +1,16 @@
-import { type AnySchema, type ProseElement } from '@jsprose/core';
-import type { EruditProcessTagArgs } from './tag.js';
-import type { EruditRawElement } from './rawElement.js';
-export type Toc = {
-    title?: string;
-    add?: boolean;
+import { type EruditRawElement } from './rawElement.js';
+export declare const NO_TOC_PREFIX = "__ERDUIT_tagNoToc";
+export type NoToc = {
+    [NO_TOC_PREFIX]: true;
 };
-export type ObjPropToc = {
-    /** Show element in the table of contents */
+export interface TocTagProp {
+    /** Whether to include the element in the table of contents. */
     toc?: boolean | string;
-};
-export type ObjRawElementToc = {
-    toc?: Toc;
-};
-export declare function finalizeToc(processTagArgs: EruditProcessTagArgs): Toc | undefined;
+}
+export interface TocRawElementProp {
+    toc?: string | boolean;
+}
+export declare function finalizeToc(rawElement: EruditRawElement, tocTagProp: TocTagProp['toc']): void;
 export type ResolvedTocHeading = {
     type: 'heading';
     level: 1 | 2 | 3;
@@ -27,8 +25,4 @@ export type ResolvedTocElement = {
     elementId: string;
 };
 export type ResolvedTocItem = ResolvedTocHeading | ResolvedTocElement;
-export declare const tocItemStep: ({ rawElement, proseElement }: {
-    context: import("./context.js").EruditProseContext;
-    rawElement: EruditRawElement<AnySchema>;
-    proseElement: ProseElement<AnySchema>;
-}) => ResolvedTocHeading | ResolvedTocElement | undefined;
+export declare const tocHook: import("./rawToProse/hook.js").RawToProseHook;

package/dist/toc.js

@@ -1,52 +1,130 @@
-import { ProseError } from "@jsprose/core";
 import { headingSchema } from "./elements/heading/core.js";
-import { defineResolveStep } from "./resolveStep.js";
-export function finalizeToc(processTagArgs) {
-	const propToc = processTagArgs.props.toc;
-	if (propToc === false) {
-		return undefined;
+import { EruditProseError } from "./error.js";
+import { defineRawToProseHook } from "./rawToProse/hook.js";
+import { isEruditRawElement } from "./rawElement.js";
+export const NO_TOC_PREFIX = "__ERDUIT_tagNoToc";
+export function finalizeToc(rawElement, tocTagProp) {
+	if (tocTagProp === false) {
+		// Explicitly prohibit to add to TOC
+		rawElement.toc = false;
+		return;
 	}
-	if (propToc === true) {
-		const title = finalizeTocTitle(processTagArgs);
-		return { title };
+	if (typeof tocTagProp === "string") {
+		// Explicitly add to TOC with custom title
+		const tocString = tocTagProp.trim();
+		if (!tocString) {
+			throw new EruditProseError("Addition to TOC was requested via direct tag toc prop but it is an empty string!");
+		}
+		rawElement.toc = tocString;
+		return;
+	}
+	if (rawElement.toc === true) {
+		// Implicitly add to TOC using general title
+		const tocString = rawElement.title?.trim();
+		if (!tocString) {
+			throw new EruditProseError("Addition to TOC was requested via internal toc: true flag, but unable to retrieve title!");
+		}
+		rawElement.toc = tocString;
+		return;
 	}
-	if (typeof propToc === "string") {
-		const manualTocTitle = finalizeTocTitle(processTagArgs);
-		return { title: manualTocTitle };
+	if (rawElement.toc === false) {
+		// Implicitly set to not to add to TOC
+		return;
 	}
-	if (processTagArgs.element.toc) {
-		if (processTagArgs.element.toc.add) {
-			const tocTitle = finalizeTocTitle(processTagArgs);
-			return { title: tocTitle };
+	if (tocTagProp === true) {
+		// Explicitly add to TOC using general internal toc string or general title
+		const tocString = rawElement.toc?.trim() || rawElement.title?.trim();
+		if (!tocString) {
+			throw new EruditProseError("Addition to TOC was manually requested via true tag toc prop, but unable to retrieve title!");
 		}
+		rawElement.toc = tocString;
+		return;
 	}
-}
-function finalizeTocTitle(processTagArgs) {
-	const title = (typeof processTagArgs.props.toc === "string" ? processTagArgs.props.toc.trim() : "") || processTagArgs.element.toc?.title?.trim() || processTagArgs.element.title?.trim();
-	if (title) {
-		return title;
+	if (typeof rawElement.toc === "string") {
+		// Check if internal toc string is valid
+		const tocString = rawElement.toc?.trim();
+		if (!tocString) {
+			throw new EruditProseError("Addition to TOC was requested via internal toc string, but it is empty!");
+		}
+		rawElement.toc = tocString;
 	}
-	throw new ProseError("Unable to finalize TOC title!");
 }
-export const tocItemStep = defineResolveStep(({ rawElement, proseElement }) => {
-	if (rawElement.toc?.title && proseElement.id) {
-		if (rawElement.schemaName === headingSchema.name) {
-			const tocItem = {
-				type: "heading",
-				level: rawElement.data.level,
-				title: rawElement.toc.title,
-				elementId: proseElement.id,
-				children: []
-			};
-			return tocItem;
-		} else {
-			const tocItem = {
-				type: "element",
-				schemaName: rawElement.schemaName,
-				title: rawElement.toc.title,
-				elementId: proseElement.id
-			};
-			return tocItem;
-		}
+export const tocHook = defineRawToProseHook(({ task: context, result }) => {
+	if (!context.toc?.enabled) {
+		return;
 	}
+	const addSchemas = context.toc?.addSchemas || [];
+	const headingStack = [];
+	return { step: ({ rawElement, proseElement }) => {
+		let tocItem;
+		if (proseElement.id) {
+			if (typeof rawElement.toc === "string") {
+				if (isEruditRawElement(rawElement, headingSchema)) {
+					tocItem = {
+						type: "heading",
+						level: rawElement.data.level,
+						title: rawElement.toc,
+						elementId: proseElement.id,
+						children: []
+					};
+				} else {
+					tocItem = {
+						type: "element",
+						schemaName: rawElement.schema.name,
+						title: rawElement.toc,
+						elementId: proseElement.id
+					};
+				}
+			}
+			// Try force add specified schemas
+			// Only attempt for elements where toc was never explicitly excluded.
+			if (!tocItem && rawElement.toc !== false && addSchemas.some((schema) => isEruditRawElement(rawElement, schema))) {
+				try {
+					finalizeToc(rawElement, true);
+					if (typeof rawElement.toc === "string") {
+						tocItem = {
+							type: "element",
+							schemaName: rawElement.schema.name,
+							title: rawElement.toc,
+							elementId: proseElement.id
+						};
+					}
+				} catch {}
+			}
+		}
+		if (tocItem) {
+			if (tocItem.type === "heading") {
+				// Pop headings from stack that are same level or deeper
+				while (headingStack.length > 0) {
+					const lastItem = headingStack[headingStack.length - 1];
+					if (lastItem.type === "heading" && lastItem.level >= tocItem.level) {
+						headingStack.pop();
+					} else {
+						break;
+					}
+				}
+				// Add to parent or root
+				if (headingStack.length > 0) {
+					const parent = headingStack[headingStack.length - 1];
+					if (parent.type === "heading") {
+						parent.children.push(tocItem);
+					}
+				} else {
+					result.toc.push(tocItem);
+				}
+				// Push this heading to stack
+				headingStack.push(tocItem);
+			} else {
+				// Non-heading item: add to most recent heading or root
+				if (headingStack.length > 0) {
+					const parent = headingStack[headingStack.length - 1];
+					if (parent.type === "heading") {
+						parent.children.push(tocItem);
+					}
+				} else {
+					result.toc.push(tocItem);
+				}
+			}
+		}
+	} };
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@erudit-js/prose",
-  "version": "4.1.0",
+  "version": "4.2.0-dev.1",
   "description": "📝 JSX prose subsystem for Erudit sites",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -18,7 +18,7 @@
       "import": "./dist/elements/*.js",
       "types": "./dist/elements/*.d.ts"
     },
-    "./types": "./types.d.ts"
+    "./raw": "./raw.d.ts"
   },
   "files": [
     "dist",
@@ -32,16 +32,17 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@erudit-js/core": "4.1.0",
+    "@erudit-js/core": "4.2.0-dev.1",
     "@floating-ui/vue": "^1.1.10",
-    "@jsprose/core": "^1.0.0",
+    "tsprose": "^1.0.0",
     "image-size": "^2.0.2",
     "katex": "^0.16.28",
     "photoswipe": "^5.4.4",
-    "vue": "^3.5.27"
+    "vue": "^3.5.28"
   },
   "devDependencies": {
     "glob": "13.0.0",
-    "oxc-transform": "0.112.0"
+    "oxc-transform": "0.112.0",
+    "ts-xor": "^1.3.0"
   }
 }

package/dist/app/default/Inliners.vue

@@ -1,11 +0,0 @@
-<script lang="ts" setup>
-import type { inlinersSchema, ProseElement } from '@jsprose/core';
-
-import Render from '../shared/Render.vue';
-
-defineProps<{ element: ProseElement<typeof inlinersSchema> }>();
-</script>
-
-<template>
-  <Render v-for="child of element.children" :element="child" />
-</template>

package/dist/context.d.ts

@@ -1,4 +0,0 @@
-export interface EruditProseContext {
-    language: string;
-    linkable?: boolean;
-}

package/dist/context.js

@@ -1 +0,0 @@
-export {};

package/dist/elements/link/step.d.ts

@@ -1,16 +0,0 @@
-export type ContentLinkTag = 'Dep' | 'Dependency' | 'Ref' | 'Reference';
-export interface ContentLinkUsage {
-    type: ContentLinkTag;
-    label: string;
-}
-export type ContentLinks = Map<string, ContentLinkUsage[]>;
-export interface ContentLinkStepReturn {
-    storageKey: string;
-    label: string;
-    type: ContentLinkTag;
-}
-export declare const contentLinkStep: ({ rawElement, proseElement }: {
-    context: import("../../context.js").EruditProseContext;
-    rawElement: import("../../rawElement.js").EruditRawElement<import("@jsprose/core").AnySchema>;
-    proseElement: import("@jsprose/core").ProseElement<import("@jsprose/core").AnySchema>;
-}) => ContentLinkStepReturn | undefined;

package/dist/elements/link/step.js

@@ -1,36 +0,0 @@
-import { isRawElement } from "@jsprose/core";
-import { defineResolveStep } from "../../resolveStep.js";
-import { dependencySchema, depSchema } from "./dependency/core.js";
-import { referenceSchema, refSchema } from "./reference/core.js";
-export const contentLinkStep = defineResolveStep(({ rawElement, proseElement }) => {
-	if (!proseElement.id || !rawElement.storageKey) {
-		return;
-	}
-	const checks = [
-		{
-			schema: depSchema,
-			key: "Dep"
-		},
-		{
-			schema: dependencySchema,
-			key: "Dependency"
-		},
-		{
-			schema: refSchema,
-			key: "Ref"
-		},
-		{
-			schema: referenceSchema,
-			key: "Reference"
-		}
-	];
-	for (const { schema, key } of checks) {
-		if (isRawElement(rawElement, schema)) {
-			return {
-				storageKey: rawElement.storageKey,
-				label: rawElement.data.label.trim(),
-				type: key
-			};
-		}
-	}
-});

package/dist/elements/problem/step.d.ts

@@ -1,5 +0,0 @@
-export declare const problemScriptStep: ({ rawElement }: {
-    context: import("../../context.js").EruditProseContext;
-    rawElement: import("../../rawElement.js").EruditRawElement<import("@jsprose/core").AnySchema>;
-    proseElement: import("@jsprose/core").ProseElement<import("@jsprose/core").AnySchema>;
-}) => string | undefined;