@canofold/markdown 0.2.0

package/dist/client/chunks/table-JOSJsHgy.js

@@ -0,0 +1,30 @@
+import { c as l, j as t } from "./react-runtime-Dzgdzn6D.js";
+import { a as s, b as d } from "./serialized-T1PzI4rG.js";
+import { w as b } from "./provider-DNSHvvN7.js";
+function f(a, e) {
+  return l.hydrateRoot(
+    a,
+    b(
+      /* @__PURE__ */ t.jsx(
+        s,
+        {
+          className: a.className,
+          tableTitle: a.dataset.cfTableTitle,
+          copyLabel: a.dataset.cfCopyLabel,
+          copyFailureLabel: a.dataset.cfCopyFailureLabel,
+          downloadLabel: a.dataset.cfDownloadLabel,
+          zoomLabel: a.dataset.cfZoomLabel,
+          closeLabel: a.dataset.cfCloseLabel,
+          sortLabel: a.dataset.cfSortLabel,
+          serializedTable: a.dataset.cfTable,
+          inner: !0,
+          children: d(a.dataset.cfTable, e)
+        }
+      ),
+      e
+    )
+  );
+}
+export {
+  f as hydrate
+};

package/dist/client/chunks/table-PQvrpt1p.js

@@ -0,0 +1,30 @@
+import { c as l, j as d } from "./react-runtime-Dzgdzn6D.js";
+import { a as t, b as s } from "./serialized-DajnRKXi.js";
+import { w as b } from "./provider-SSQfNDJA.js";
+function n(a, e) {
+  return l.hydrateRoot(
+    a,
+    b(
+      /* @__PURE__ */ d.jsx(
+        t,
+        {
+          className: a.className,
+          tableTitle: a.dataset.dfTableTitle,
+          copyLabel: a.dataset.dfCopyLabel,
+          copyFailureLabel: a.dataset.dfCopyFailureLabel,
+          downloadLabel: a.dataset.dfDownloadLabel,
+          zoomLabel: a.dataset.dfZoomLabel,
+          closeLabel: a.dataset.dfCloseLabel,
+          sortLabel: a.dataset.dfSortLabel,
+          serializedTable: a.dataset.dfTable,
+          inner: !0,
+          children: s(a.dataset.dfTable, e)
+        }
+      ),
+      e
+    )
+  );
+}
+export {
+  n as hydrate
+};

package/dist/client/index.js

@@ -0,0 +1,4 @@
+import { e as n } from "./chunks/client-kVNIqHQd.js";
+export {
+  n as enhanceMarkdown
+};

package/dist/client/nativeBehaviors.d.ts

@@ -0,0 +1,4 @@
+import type { MarkdownBehaviorName } from '../compiler/assets';
+/** Behaviors implemented through reversible delegated DOM enhancement. */
+export declare const NATIVE_MARKDOWN_BEHAVIOR_NAMES: readonly ["code-toolbar", "copy-snippet", "terminal-toolbar", "heading", "tabs", "details", "file-tree"];
+export declare function enhanceNativeMarkdown(root: ParentNode, behaviors: readonly MarkdownBehaviorName[]): () => void;

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import { type MarkdownAssets } from './compiler/assets';
+export interface MarkdownEnhancement {
+    /** Resolves when all requested rich behaviors have loaded. */
+    ready: Promise<void>;
+    /** Removes native listeners and unmounts rich behavior roots. */
+    dispose(): void;
+}
+/**
+ * Enhance the semantic Markdown DOM produced by the server renderer.
+ *
+ * The implementation chooses native DOM behavior or a lazy rich runtime for
+ * each resource fact; hosts do not need to know how an interaction is built.
+ */
+export declare function enhanceMarkdown(root?: ParentNode, assets?: Pick<MarkdownAssets, 'behaviors'>): MarkdownEnhancement;
+export type { MarkdownAssets, MarkdownBehaviorName } from './compiler/assets';

package/dist/compiler/analyze.d.ts

@@ -0,0 +1,27 @@
+import { type MarkdownDirectiveIssue } from './directiveValidation';
+import type { MarkdownPlugin } from './types';
+export interface MarkdownHeading {
+    level: number;
+    text: string;
+    slug: string;
+}
+export interface MarkdownCodeExample {
+    language: string;
+    meta?: string;
+    code: string;
+}
+export interface MarkdownAnalysis {
+    text: string;
+    headings: MarkdownHeading[];
+    codeExamples: MarkdownCodeExample[];
+    links: string[];
+    images: string[];
+    missingCodeBlockLanguages: number;
+    directiveIssues: MarkdownDirectiveIssue[];
+}
+export interface AnalyzeMarkdownOptions {
+    /** Plugins whose declared directives should be accepted for this source. */
+    plugins?: readonly MarkdownPlugin[];
+}
+/** Parse navigation/search metadata using syntax that is always part of the Markdown core. */
+export declare function analyzeMarkdown(source: string, options?: AnalyzeMarkdownOptions): MarkdownAnalysis;

package/dist/compiler/assets.d.ts

@@ -0,0 +1,29 @@
+import type { MarkdownPlugin, MarkdownPluginClientAsset, MarkdownPluginStyleAsset } from './types';
+export interface MarkdownAssets {
+    /** Browser behaviors required by the rendered document. */
+    behaviors: MarkdownBehaviorName[];
+    /** Whether the document needs KaTeX CSS and font resources. */
+    math: boolean;
+    /** Browser entries contributed by active compiler plugins. */
+    pluginClients: MarkdownPluginClientAsset[];
+    /** Published CSS entries contributed by active compiler plugins. */
+    pluginStyles: MarkdownPluginStyleAsset[];
+}
+/** Canonical browser behavior facts shared by the compiler and client runtime. */
+export declare const MARKDOWN_BEHAVIOR_NAMES: readonly ["gallery", "code-toolbar", "copy-snippet", "terminal-toolbar", "table", "image", "heading", "tabs", "details", "file-tree"];
+export type MarkdownBehaviorName = (typeof MARKDOWN_BEHAVIOR_NAMES)[number];
+export interface MarkdownAssetCollector {
+    markBehavior(name: MarkdownBehaviorName): void;
+    markMath(): void;
+    markPluginAssets(plugin: MarkdownPlugin): void;
+    snapshot(): MarkdownAssets;
+}
+export declare function createMarkdownAssetCollector(): MarkdownAssetCollector;
+/**
+ * Conservative source-level detection for MDX pages.
+ *
+ * MDX is evaluated by its own compiler, so it cannot reuse the Markdown HAST
+ * visitor without first executing trusted JSX. This detector intentionally
+ * prefers a false positive over omitting an interaction script.
+ */
+export declare function detectMarkdownAssets(source: string, plugins?: readonly MarkdownPlugin[], mode?: 'markdown' | 'mdx'): MarkdownAssets;

package/dist/compiler/ast.d.ts

@@ -0,0 +1,68 @@
+import type { BlockContent, Data, RootContent } from 'mdast';
+import type { Properties } from 'hast';
+import type { Parent } from 'unist';
+interface TabItemData extends Data {
+    tabLabel: string;
+    tabLanguage?: string;
+    tabValue: string;
+    tabIndex: number;
+}
+export interface TabItem extends Parent {
+    type: 'tabItem';
+    data: TabItemData;
+    children: BlockContent[];
+}
+interface TabGroupData extends Data {
+    tabGroupLabel: string;
+    tabGroupKind: 'tabs' | 'code-group';
+}
+export interface TabGroup extends Parent {
+    type: 'tabGroup';
+    data: TabGroupData;
+    children: TabItem[];
+}
+interface StepItemData extends Data {
+    stepTitle: string;
+    stepIndex: number;
+}
+export interface StepItem extends Parent {
+    type: 'stepItem';
+    data: StepItemData;
+    children: BlockContent[];
+}
+interface StepGroupData extends Data {
+    stepLabel: string;
+}
+export interface StepGroup extends Parent {
+    type: 'stepGroup';
+    data: StepGroupData;
+    children: StepItem[];
+}
+export interface CalloutPart extends Parent {
+    type: 'calloutBody' | 'calloutTitle';
+    children: RootContent[];
+}
+declare module 'unist' {
+    interface Data {
+        directiveLabel?: boolean | null;
+        hName?: string;
+        hProperties?: Properties;
+    }
+}
+declare module 'mdast' {
+    interface BlockContentMap {
+        tabGroup: TabGroup;
+        tabItem: TabItem;
+        stepGroup: StepGroup;
+        stepItem: StepItem;
+        calloutPart: CalloutPart;
+    }
+    interface RootContentMap {
+        tabGroup: TabGroup;
+        tabItem: TabItem;
+        stepGroup: StepGroup;
+        stepItem: StepItem;
+        calloutPart: CalloutPart;
+    }
+}
+export {};

package/dist/compiler/createPipeline.d.ts

@@ -0,0 +1,18 @@
+import { type Pluggable, type Plugin, type Transformer } from 'unified';
+import type { Root as HastRoot } from 'hast';
+import type { MarkdownAssetCollector } from './assets';
+import type { NormalizedMarkdownOptions } from './normalizeOptions';
+import type { MarkdownSyntaxFeatures } from './syntaxFeatures';
+import type { Options as SanitizeOptions } from 'rehype-sanitize';
+interface CreateMarkdownProcessorOptions {
+    assets: MarkdownAssetCollector;
+    options: NormalizedMarkdownOptions;
+    rehypeRaw?: () => Transformer<HastRoot, HastRoot>;
+    rehypeSanitize?: Plugin<[SanitizeOptions?], HastRoot, HastRoot>;
+    sanitizeSchema?: SanitizeOptions;
+    syntax: MarkdownSyntaxFeatures;
+    syntaxHighlighter?: Pluggable;
+}
+/** Assemble Markdown and MDX from the same ordered plugin plan. */
+export declare function createMarkdownProcessor({ assets, options, rehypeRaw, rehypeSanitize, sanitizeSchema, syntax, syntaxHighlighter }: CreateMarkdownProcessorOptions): import("unified").Processor<import("mdast").Root, import("mdast").Root, HastRoot, undefined, undefined>;
+export {};

package/dist/compiler/defaultLabels.d.ts

@@ -0,0 +1,28 @@
+export declare const DEFAULT_MARKDOWN_LABELS: {
+    copyCode: string;
+    copyFailed: string;
+    copySnippet: string;
+    copyTerminal: string;
+    terminalTitle: string;
+    tabsTitle: string;
+    tabItem: string;
+    codeGroupTitle: string;
+    codeGroupItem: string;
+    taskCompleted: string;
+    taskIncomplete: string;
+    copySectionLink: string;
+    tableTitle: string;
+    copyTableCsv: string;
+    downloadTableCsv: string;
+    zoomTable: string;
+    closeTablePreview: string;
+    sortTableColumn: string;
+    zoomImage: string;
+    closeImagePreview: string;
+    imageGallery: string;
+    closeImageGallery: string;
+    previousGalleryImage: string;
+    nextGalleryImage: string;
+    galleryThumbnails: string;
+    galleryImage: string;
+};

package/dist/compiler/directiveValidation.d.ts

@@ -0,0 +1,17 @@
+import type { Root } from 'mdast';
+import type { Node } from 'unist';
+export interface MarkdownDirectiveIssue {
+    message: string;
+    line?: number;
+    column?: number;
+}
+interface LocatedDirectiveIssue extends MarkdownDirectiveIssue {
+    node: Node;
+}
+/** Validate the public Canofold directive grammar and explicitly declared plugin directives. */
+export declare function collectRichDirectiveIssues(tree: Root, pluginDirectiveNames?: ReadonlySet<string>): LocatedDirectiveIssue[];
+/** Stop rendering malformed core directives before a transform can discard content. */
+export declare const remarkValidateRichDirectives: (pluginDirectiveNames?: ReadonlySet<string>) => (tree: Root, file: {
+    fail(message: string, node?: Node): never;
+}) => void;
+export {};

package/dist/compiler/highlighter.d.ts

@@ -0,0 +1,3 @@
+import type { Pluggable } from 'unified';
+import type { NormalizedMarkdownOptions } from './normalizeOptions';
+export declare function createSyntaxHighlighterPlugin(codeLanguages: readonly string[], options: NormalizedMarkdownOptions, warnedLanguages?: Set<string>, excludedLanguages?: ReadonlySet<string>): Promise<Pluggable>;

package/dist/compiler/mdxModules.d.ts

@@ -0,0 +1,19 @@
+export interface MdxImportBinding {
+    imported: string;
+    local: string;
+    namespace?: boolean;
+}
+export interface MdxImportDeclaration {
+    specifier: string;
+    bindings: MdxImportBinding[];
+}
+export interface MdxModuleBoundary {
+    imports: MdxImportDeclaration[];
+    sourceWithoutImports: string;
+    unsupportedReferences: Array<{
+        kind: 'dynamic-import' | 'export-from';
+        specifier?: string;
+    }>;
+}
+/** Parse only real top-level MDX module syntax, leaving fenced examples intact. */
+export declare function analyzeMdxModuleBoundary(source: string): MdxModuleBoundary;

package/dist/compiler/mdxPlugins.d.ts

@@ -0,0 +1,16 @@
+import { type MarkdownAssets } from './assets';
+import type { RenderMarkdownOptions } from './types';
+import type { PluggableList } from 'unified';
+import type { MarkdownHandlers } from './pluginPlan';
+import type { MarkdownCompilerContext } from './prepareMarkdown';
+interface MarkdownMdxPlugins {
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    remarkRehypeOptions: {
+        handlers: MarkdownHandlers;
+    };
+    getAssets: () => MarkdownAssets;
+}
+/** MDX owns JSX evaluation while sharing Markdown's ordered plugin plan. */
+export declare function createMarkdownMdxPlugins(options?: RenderMarkdownOptions, source?: string, context?: MarkdownCompilerContext): Promise<MarkdownMdxPlugins>;
+export {};

package/dist/compiler/normalizeOptions.d.ts

@@ -0,0 +1,16 @@
+import type { LanguageInput, ThemeRegistration } from '@shikijs/types';
+import type { MarkdownFeatureOptions, MarkdownHtmlPolicy, MarkdownLabels, MarkdownPlugin, MarkdownUnknownLanguagePolicy, RenderMarkdownOptions } from './types';
+export interface NormalizedMarkdownOptions {
+    htmlPolicy: MarkdownHtmlPolicy;
+    codeThemes: {
+        light: string | ThemeRegistration;
+        dark: string | ThemeRegistration;
+    };
+    fallbackLanguage: string;
+    codeLanguages: Readonly<Record<string, LanguageInput>>;
+    unknownLanguage: MarkdownUnknownLanguagePolicy;
+    features: Required<MarkdownFeatureOptions>;
+    labels: MarkdownLabels;
+    plugins: readonly MarkdownPlugin[];
+}
+export declare function normalizeOptions(options?: RenderMarkdownOptions): NormalizedMarkdownOptions;

package/dist/compiler/pluginPlan.d.ts

@@ -0,0 +1,18 @@
+import type { Options as RemarkRehypeOptions } from 'remark-rehype';
+import type { Pluggable, PluggableList } from 'unified';
+import type { MarkdownAssetCollector } from './assets';
+import type { NormalizedMarkdownOptions } from './normalizeOptions';
+import { rehypeStepGroup, rehypeStepItem, rehypeTabGroup, rehypeTabItem } from './plugins/directives';
+import type { MarkdownSyntaxFeatures } from './syntaxFeatures';
+export interface MarkdownPluginPlan {
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+    handlers: MarkdownHandlers;
+}
+export type MarkdownHandlers = NonNullable<RemarkRehypeOptions['handlers']> & {
+    tabGroup: typeof rehypeTabGroup;
+    tabItem: typeof rehypeTabItem;
+    stepGroup: typeof rehypeStepGroup;
+    stepItem: typeof rehypeStepItem;
+};
+export declare function createMarkdownPluginPlan(mode: 'markdown' | 'mdx', assets: MarkdownAssetCollector, options: NormalizedMarkdownOptions, syntax: MarkdownSyntaxFeatures, syntaxHighlighter?: Pluggable): MarkdownPluginPlan;

package/dist/compiler/plugins/code.d.ts

@@ -0,0 +1,16 @@
+import type { Root as HastRoot } from 'hast';
+import type { Root as MdastRoot } from 'mdast';
+import type { MarkdownAssetCollector } from '../assets';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+/** Track explicit React components embedded in trusted MDX. */
+export declare const remarkMdxIslandTracker: (assets: MarkdownAssetCollector) => (tree: MdastRoot) => void;
+/** Preserve fenced block metadata through raw HTML sanitization. */
+export declare const remarkFenceMetadata: (options: NormalizedMarkdownOptions) => (tree: MdastRoot) => void;
+/** Copy authored code titles onto the pre element before Shiki replaces code children. */
+export declare const rehypeFenceMetadata: () => (tree: HastRoot) => void;
+/** Convert special fenced code into serializable inputs for React blocks. */
+export declare const rehypeRichFences: (assets: MarkdownAssetCollector, options: NormalizedMarkdownOptions) => (tree: HastRoot) => void;
+/** Convert rich fences into React components for the MDX recma pipeline. */
+export declare const remarkMdxRichBlocks: (assets: MarkdownAssetCollector, options: NormalizedMarkdownOptions) => (tree: MdastRoot) => void;
+/** Wrap each highlighted code block with a file/language label and copy action. */
+export declare const rehypeCodeBlocks: (assets: MarkdownAssetCollector, labels: NormalizedMarkdownOptions["labels"], excludedLanguages?: ReadonlySet<string>) => (tree: HastRoot) => void;

package/dist/compiler/plugins/directives.d.ts

@@ -0,0 +1,24 @@
+import type { Element, Root as HastRoot } from 'hast';
+import type { Root } from 'mdast';
+import type { State } from 'mdast-util-to-hast';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+import type { StepGroup, StepItem, TabGroup, TabItem } from '../ast';
+/**
+ * Keep the authoring interface small: directives describe intent and the
+ * compiler owns every `cf-*` class, data attribute, slot, and ARIA detail.
+ */
+export declare const remarkRichDirectives: () => (tree: Root) => void;
+/** Finish rich directive structure after Markdown has become semantic HTML. */
+export declare const rehypeRichDirectives: () => (tree: HastRoot) => void;
+/** Allow the friendly `:::tip 标题` authoring syntax. */
+export declare function normalizeCallouts(markdown: string): string;
+/** Convert stable Tabs and Code Group directives into the shared tab model. */
+export declare const remarkTabGroups: (options: NormalizedMarkdownOptions) => (tree: Root) => void;
+/** Convert Steps directives into the shared ordered-list visual contract. */
+export declare const remarkSteps: (options: NormalizedMarkdownOptions) => (tree: Root) => void;
+export declare function rehypeStepItem(state: State, node: StepItem): Element;
+export declare function rehypeStepGroup(state: State, node: StepGroup): Element;
+export declare function rehypeTabItem(state: State, node: TabItem): Element;
+export declare function rehypeTabGroup(state: State, node: TabGroup): Element;
+/** Map `:::tip` containers onto the shared callout markup. */
+export declare const remarkCallouts: () => (tree: Root) => void;

package/dist/compiler/plugins/documentBlocks.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'hast';
+import type { MarkdownAssetCollector } from '../assets';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+/** Add document-level semantics shared by the static and React renderers. */
+export declare const rehypeDocumentBlocks: (assets: MarkdownAssetCollector, labels: NormalizedMarkdownOptions["labels"]) => (tree: Root) => void;

package/dist/compiler/plugins/tables.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'hast';
+import type { MarkdownAssetCollector } from '../assets';
+import type { NormalizedMarkdownOptions } from '../normalizeOptions';
+/** Turn GFM tables into a serializable data block; React owns table UI/state. */
+export declare const rehypeTables: (assets: MarkdownAssetCollector, labels: NormalizedMarkdownOptions["labels"]) => (tree: Root) => void;

package/dist/compiler/plugins.d.ts

@@ -0,0 +1,24 @@
+import type { MarkdownPlugin, MarkdownPluginContext } from './types';
+/** Validate plugin names and reject duplicates before the plan consumes them. */
+export declare function normalizeMarkdownPlugins(plugins?: readonly MarkdownPlugin[]): readonly MarkdownPlugin[];
+/**
+ * Serializable identity used by render caches and build fingerprints. Plugin
+ * functions cannot be fingerprinted, so `name`, `version` and `cacheKey` form
+ * the invalidation contract: bump `version` when the transform changes and
+ * derive `cacheKey` from resolved options.
+ */
+export declare function markdownPluginsIdentity(plugins?: readonly MarkdownPlugin[]): {
+    name: string;
+    version: string;
+    cacheKey: string | number | boolean | import("./types").MarkdownPluginCacheValue[] | {
+        [key: string]: import("./types").MarkdownPluginCacheValue;
+    } | null;
+}[];
+/** Typed identity helper that validates the plugin shape eagerly. */
+export declare function defineMarkdownPlugin(plugin: MarkdownPlugin): MarkdownPlugin;
+/** Resolve the plugins that apply to one source document. */
+export declare function activeMarkdownPlugins(plugins: readonly MarkdownPlugin[], context: MarkdownPluginContext): readonly MarkdownPlugin[];
+/** Collect normalized fenced-code labels owned by the active plugins. */
+export declare function markdownPluginFenceLanguages(plugins: readonly MarkdownPlugin[]): ReadonlySet<string>;
+/** Collect normalized directive names owned by the active plugins. */
+export declare function markdownPluginDirectiveNames(plugins: readonly MarkdownPlugin[]): ReadonlySet<string>;

package/dist/compiler/prepareMarkdown.d.ts

@@ -0,0 +1,11 @@
+import type { PreparedMarkdown, RenderMarkdownOptions } from './types';
+export type { MarkdownAssets } from './assets';
+export type { MarkdownCodeOptions, MarkdownFeatureOptions, MarkdownHtmlPolicy, MarkdownLabels, MarkdownPlugin, MarkdownPluginBrowserCompiler, MarkdownPluginCacheValue, MarkdownPluginClientAsset, MarkdownPluginClientResource, MarkdownPluginClientResourceDirectory, MarkdownPluginContext, MarkdownPluginStyleAsset, MarkdownUnknownLanguagePolicy, RenderMarkdownOptions } from './types';
+export interface MarkdownCompilerContext {
+    warnedLanguages: Set<string>;
+}
+/**
+ * Prepare Markdown as a transformed HAST document for the package's React
+ * renderers. This compiler boundary remains internal to the package.
+ */
+export declare function prepareMarkdown(source: string, options?: RenderMarkdownOptions, context?: MarkdownCompilerContext): Promise<PreparedMarkdown>;

package/dist/compiler/sanitizeBoundary.d.ts

@@ -0,0 +1,18 @@
+import type { Root } from 'hast';
+import type { Options as SanitizeOptions } from 'rehype-sanitize';
+import type { Plugin } from 'unified';
+export interface CompilerSanitizeBoundary {
+    mark: Plugin<[], Root, Root>;
+    protect: Plugin<[], Root, Root>;
+    restore: Plugin<[], Root, Root>;
+    schema: SanitizeOptions;
+}
+/**
+ * Preserve trusted compiler contracts while the default rehype schema cleans
+ * author HTML. This includes ids generated by remark-rehype: sanitizing those
+ * ids a second time would break footnote references. Raw author HTML is not an
+ * element until after `mark`, so its ids still receive the sanitizer's clobber
+ * prefix. A per-render nonce prevents authored markup from forging the
+ * temporary bridge, and only the exact compiler snapshots are restored.
+ */
+export declare function createCompilerSanitizeBoundary(defaultSchema: SanitizeOptions): CompilerSanitizeBoundary;

package/dist/compiler/stableJson.d.ts

@@ -0,0 +1,2 @@
+/** Deterministic JSON used only for optional cache identities. */
+export declare function stableJson(value: unknown): string | undefined;

package/dist/compiler/syntaxFeatures.d.ts

@@ -0,0 +1,10 @@
+export interface MarkdownSyntaxFeatures {
+    highlightedCode: boolean;
+    codeLanguages: readonly string[];
+}
+/**
+ * Cheap line scan used to skip transforms that cannot match. Tracking the
+ * opening marker prevents fenced examples inside longer fences from being
+ * mistaken for real code blocks.
+ */
+export declare function detectMarkdownSyntax(source?: string, pluginFenceLanguages?: ReadonlySet<string>): MarkdownSyntaxFeatures;