tsprose 0.0.1

package/dist/index.js

@@ -0,0 +1,17 @@
+export * from './default/mix.js';
+export * from './default/text.js';
+export * from './utils/hash.js';
+export * from './children.js';
+export * from './document.js';
+export * from './element.js';
+export * from './elementUtils.js';
+export * from './error.js';
+export * from './id.js';
+export * from './json.js';
+export * from './rawToProse.js';
+export * from './schema.js';
+export * from './storage.js';
+export * from './tag.js';
+export * from './tagUtils.js';
+export * from './unique.js';
+export * from './walk.js';

package/dist/json.d.ts

@@ -0,0 +1,2 @@
+export declare function toJSON(value: unknown, indent?: number): string;
+export declare function fromJSON(json: string): any;

package/dist/json.js

@@ -0,0 +1,46 @@
+import { PROSE_ELEMENT_PREFIX, RAW_ELEMENT_PREFIX } from './element.js';
+import { SCHEMA_PREFIX } from './schema.js';
+function encodeSchema(schema) {
+    return (schema.name +
+        (schema.type === 'block' ? '0' : '1') +
+        (schema.linkable === false ? '0' : schema.linkable === 'always' ? '2' : '1'));
+}
+function decodeSchema(encoded) {
+    const name = encoded.slice(0, -2);
+    const typeFlag = encoded.at(-2);
+    const linkFlag = encoded.at(-1);
+    return {
+        [SCHEMA_PREFIX]: true,
+        name,
+        type: typeFlag === '0' ? 'block' : 'inliner',
+        linkable: linkFlag === '0' ? false : linkFlag === '2' ? 'always' : true,
+    };
+}
+function isElement(obj) {
+    return obj[RAW_ELEMENT_PREFIX] === true || obj[PROSE_ELEMENT_PREFIX] === true;
+}
+export function toJSON(value, indent) {
+    return JSON.stringify(value, function (key, val) {
+        if (!isElement(this))
+            return val;
+        if (key === RAW_ELEMENT_PREFIX || key === PROSE_ELEMENT_PREFIX) {
+            const schema = this.schema;
+            return encodeSchema(schema);
+        }
+        if (key === 'schema') {
+            return undefined;
+        }
+        return val;
+    }, indent);
+}
+export function fromJSON(json) {
+    return JSON.parse(json, function (key, val) {
+        if ((key === RAW_ELEMENT_PREFIX || key === PROSE_ELEMENT_PREFIX) &&
+            typeof val === 'string') {
+            const schema = decodeSchema(val);
+            this.schema = schema;
+            return true;
+        }
+        return val;
+    });
+}

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from './jsx-runtime.js';

package/dist/jsx-dev-runtime.js

@@ -0,0 +1 @@
+export * from './jsx-runtime.js';

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,25 @@
+import { mixSchema } from './default/mix.js';
+import type { RawElement, ToRawElement } from './element.js';
+declare global {
+    namespace JSX {
+        /** No intrinsic elements to avoid first letter casing confusion. */
+        interface IntrinsicElements {
+        }
+        /**
+         * Unfortunately, JSX/TSX tag constructions (<...>) always return general JSX.Element type.
+         * No matter what tag you use, it will be widened to JSX.Element loosing all generics.
+         * This prevents some cool compile/editor time checkings like prohibiting certain tags in specific contexts (blocks in inliners and etc.)
+         * All this has to be done in runtime or with other tools, like ESLint.
+         *
+         * @todo Remove this when TypeScript supports proper JSX/TSX generics.
+         * @see [TypeScript issue](https://github.com/microsoft/TypeScript/issues/21699)
+         */
+        type Element = RawElement;
+    }
+}
+export declare function Fragment(props: {
+    children: {};
+}): ToRawElement<typeof mixSchema>;
+export declare function jsx(tag: any, props: any): any;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;

package/dist/jsx-runtime.js

@@ -0,0 +1,24 @@
+import { normalizeChildren } from './children.js';
+import { mixSchema } from './default/mix.js';
+import { makeRawElement } from './elementUtils.js';
+import { TSProseError } from './error.js';
+export function Fragment(props) {
+    const children = normalizeChildren(props?.children);
+    if (!children) {
+        throw new TSProseError(`JSX Fragment must have at least one child!`);
+    }
+    return makeRawElement({
+        schema: mixSchema,
+        elementHandler: (element) => {
+            element.children = children;
+        },
+    });
+}
+export function jsx(tag, props) {
+    if (tag === Fragment) {
+        return Fragment(props);
+    }
+    return tag(props);
+}
+export const jsxs = jsx;
+export const jsxDEV = jsx;

package/dist/rawToProse.d.ts

@@ -0,0 +1,19 @@
+import type { LinkableProseElement, ProseElement, RawElement } from './element.js';
+import { type IdMaker } from './id.js';
+export type RawToProseStep = (elements: {
+    rawElement: RawElement;
+    proseElement: ProseElement;
+}) => void | Promise<void>;
+export interface RawToProseResult {
+    prose: ProseElement;
+    takenIds: Set<string>;
+    uniques: Record<string, LinkableProseElement>;
+}
+export declare function rawToProse(args: {
+    rawProse: RawElement;
+    takenIds?: Set<string>;
+    pre?: (rawElement: RawElement) => void | Promise<void>;
+    post?: (proseElement: ProseElement) => void | Promise<void>;
+    step?: RawToProseStep;
+    idMaker?: IdMaker;
+}): Promise<RawToProseResult>;

package/dist/rawToProse.js

@@ -0,0 +1,59 @@
+import { makeProseElement } from './elementUtils.js';
+import { TSProseError } from './error.js';
+import { defaultIdMaker } from './id.js';
+import { isWalkStop, walkPost } from './walk.js';
+export async function rawToProse(args) {
+    const { rawProse, pre, post, step } = args;
+    const idMaker = args.idMaker || defaultIdMaker;
+    const takenIds = new Set(args.takenIds);
+    const uniques = {};
+    const prose = await walkPost(rawProse, async (rawElement, children) => {
+        if (pre) {
+            await pre(rawElement);
+        }
+        const proseElement = makeProseElement({
+            schema: rawElement.schema,
+        });
+        if (rawElement.data) {
+            proseElement.data = rawElement.data;
+        }
+        if (rawElement.storageKey) {
+            proseElement.storageKey = rawElement.storageKey;
+        }
+        if (children) {
+            proseElement.children = children;
+        }
+        if (rawElement.schema.linkable) {
+            const elementId = idMaker(rawElement, takenIds);
+            if (takenIds.has(elementId)) {
+                throw new TSProseError(`Element ID collision: "${elementId}" is already taken!\nMake sure "idMaker" you are using generates non-repeating IDs!`);
+            }
+            proseElement.id = elementId;
+            takenIds.add(elementId);
+            if (rawElement.uniqueName) {
+                if (uniques[rawElement.uniqueName]) {
+                    throw new TSProseError(`Duplicate uniqueName: "${rawElement.uniqueName}" is already used by another element!\nIf you are using document prose, make sure not to directly insert imported or manually created external uniques as they might intersect with document uniques!`);
+                }
+                uniques[rawElement.uniqueName] = proseElement;
+            }
+        }
+        if (post) {
+            await post(proseElement);
+        }
+        if (step) {
+            await step({
+                rawElement,
+                proseElement,
+            });
+        }
+        return proseElement;
+    });
+    if (isWalkStop(prose)) {
+        throw new TSProseError('Raw to Prose walk cannot be manually stopped!');
+    }
+    return {
+        prose,
+        takenIds,
+        uniques,
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,25 @@
+export declare const SCHEMA_PREFIX = "__TSPROSE_schema";
+export type SchemaName = string;
+export type SchemaType = 'block' | 'inliner';
+export type SchemaLinkable = boolean | 'always';
+export interface Schema {
+    [SCHEMA_PREFIX]: true;
+    name: SchemaName;
+    type: SchemaType;
+    linkable: SchemaLinkable;
+    Data: any;
+    Storage: any;
+    Children: Schema[] | undefined;
+}
+export interface BlockSchema extends Schema {
+    type: 'block';
+}
+export interface InlinerSchema extends Schema {
+    type: 'inliner';
+    Children: InlinerSchema[] | undefined;
+}
+export interface LinkableSchema extends Schema {
+    linkable: true | 'always';
+}
+export type RuntimeSchema<T extends Schema> = Omit<T, 'Data' | 'Storage' | 'Children'>;
+export declare function defineSchema<T extends Schema>(runtimeSchema: Omit<RuntimeSchema<T>, typeof SCHEMA_PREFIX>): T;

package/dist/schema.js

@@ -0,0 +1,7 @@
+export const SCHEMA_PREFIX = '__TSPROSE_schema';
+export function defineSchema(runtimeSchema) {
+    return {
+        ...runtimeSchema,
+        [SCHEMA_PREFIX]: true,
+    };
+}

package/dist/storage.d.ts

@@ -0,0 +1,18 @@
+import type { ProseElement, ToProseElement } from './element.js';
+import type { Schema } from './schema.js';
+export type ProseStorage = Record<string, any>;
+export interface ProseWithStorage {
+    prose: ProseElement;
+    storage: ProseStorage;
+}
+export type ElementStorageCreator<TSchema extends Schema> = TSchema['Storage'] extends undefined ? never : (element: ToProseElement<TSchema>) => null | TSchema['Storage'] | Promise<null | TSchema['Storage']>;
+export declare function fillProseStorage(args: {
+    prose: ProseElement;
+    storageCreators: Record<string, ElementStorageCreator<any>>;
+    alterValue?: (args: {
+        element: ToProseElement<Schema>;
+        storageKey: string;
+        value: any;
+    }) => any | Promise<any>;
+    storage?: ProseStorage;
+}): Promise<ProseStorage>;

package/dist/storage.js

@@ -0,0 +1,30 @@
+import { walkPre } from './walk.js';
+export async function fillProseStorage(args) {
+    const storage = args.storage || {};
+    await walkPre(args.prose, async (element) => {
+        const storageKey = element.storageKey;
+        // Element is not supposed to have storage
+        if (!storageKey) {
+            return;
+        }
+        // Storage was already filled
+        if (storage[storageKey] !== undefined) {
+            return;
+        }
+        const storageCreator = args.storageCreators[element.schema.name];
+        let value = null;
+        const deUndefy = (value) => (value === undefined ? null : value);
+        if (storageCreator) {
+            value = deUndefy(await storageCreator(element));
+        }
+        if (args.alterValue) {
+            value = deUndefy(await args.alterValue({
+                element,
+                storageKey,
+                value,
+            }));
+        }
+        storage[storageKey] = value;
+    });
+    return storage;
+}

package/dist/tag.d.ts

@@ -0,0 +1,45 @@
+import { type NormalizedChildren } from './children.js';
+import type { ToRawElement } from './element.js';
+import type { LinkableSchema, Schema } from './schema.js';
+import { type AutoUnique, type ToUnique } from './unique.js';
+export declare const TAG_PREFIX = "__TSPROSE_tag";
+export type ToTag<TSchema extends Schema, TagName extends string, Props extends Record<string, any>> = {
+    [TAG_PREFIX]: true;
+    tagName: TagName;
+    schema: TSchema;
+} & ((props: TagProps<TSchema, TagName, Props>) => ToRawElement<TSchema, TagName>);
+export type Tag = ToTag<Schema, string, any>;
+export type LinkableTag = ToTag<LinkableSchema, string, any>;
+export type TagProps<TSchema extends Schema, TagName extends string, Props extends Record<string, any> = {}> = TagChildren<TSchema, Props> & TagLinkable<TSchema, TagName> & Props;
+export type TagChildren<TSchema extends Schema, Props> = 'children' extends keyof Props ? {} : [TSchema['Children']] extends [undefined] ? {
+    children?: never;
+} : undefined extends TSchema['Children'] ? {
+    children?: {};
+} : {
+    children: {};
+};
+export type TagLinkable<TSchema extends Schema, TagName extends string> = TSchema extends LinkableSchema ? TSchema['linkable'] extends 'always' ? {
+    $: ToUnique<ToTag<TSchema, TagName, any>> | AutoUnique;
+} : TSchema['linkable'] extends true ? {
+    $?: ToUnique<ToTag<TSchema, TagName, any>> | AutoUnique;
+} : {} : {};
+export type ValidateTagCustomProps<Props extends Record<string, any> = {}> = Extract<keyof Props, '$'> extends infer Conflict ? [Conflict] extends [never] ? Props : `Forbidden custom tag property '${Extract<Conflict, string | number | bigint>}'!` : never;
+export type NoChildren = {
+    children?: never;
+};
+export type OptionalChildren = {
+    children?: {};
+};
+export type RequiredChildren = {
+    children: {};
+};
+export declare function defineTag<TSchema extends Schema, TagName extends string>(tagParameters: {
+    tagName: TagName;
+    schema: TSchema;
+}): <const Props extends ValidateTagCustomProps<Props>>(tagElementHandler: TagElementHandler<TagName, TSchema, Props>) => ToTag<TSchema, TagName, Props>;
+export type TagElementHandler<TagName extends string, TSchema extends Schema, Props extends Record<string, any>> = (context: {
+    tagName: TagName;
+    props: TagProps<TSchema, TagName, Props>;
+    children: NormalizedChildren;
+    element: ToRawElement<TSchema, TagName>;
+}) => void;

package/dist/tag.js

@@ -0,0 +1,53 @@
+import { normalizeChildren } from './children.js';
+import { makeRawElement } from './elementUtils.js';
+import { TSProseError } from './error.js';
+import { isAutoUnique } from './unique.js';
+export const TAG_PREFIX = '__TSPROSE_tag';
+export function defineTag(tagParameters) {
+    const tagName = tagParameters.tagName;
+    if (!tagName.trim()) {
+        throw new TSProseError(`Invalid tag name "${tagName}"!`);
+    }
+    function finalizeTag(tagElementHandler) {
+        const tag = (props) => {
+            const { tagName, schema } = tagParameters;
+            const children = normalizeChildren(props.children, (child) => {
+                if (schema.type === 'inliner' && child.schema.type === 'block') {
+                    throw new TSProseError(`Inliner <${tagName}> cannot have block children! Detected block child "${child.schema.name}"!`);
+                }
+            });
+            const rawElement = makeRawElement({
+                tagName,
+                schema,
+                elementHandler: (element) => {
+                    if (props.$) {
+                        element.uniqueName = props.$.name;
+                        props.$.rawElement = element;
+                        if (isAutoUnique(props.$)) {
+                            props.$.tag = tag;
+                        }
+                    }
+                    else {
+                        if (schema.linkable === 'always') {
+                            throw new TSProseError(`Tag <${tagName}> requires a unique provided via "$" prop!`);
+                        }
+                    }
+                    tagElementHandler({
+                        tagName,
+                        props,
+                        children,
+                        element,
+                    });
+                },
+            });
+            return rawElement;
+        };
+        Object.defineProperties(tag, {
+            [TAG_PREFIX]: { value: true },
+            tagName: { value: tagName },
+            schema: { value: tagParameters.schema },
+        });
+        return tag;
+    }
+    return finalizeTag;
+}

package/dist/tagUtils.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizedChildren } from './children.js';
+import { TSProseError } from './error.js';
+import type { BlockRawElement, InlinerRawElement, ToRawElement } from './element.js';
+import type { Schema } from './schema.js';
+export declare function createTagError(tagName: string, message: string): TSProseError;
+export declare function ensureTagNoChildren(tagName: string, children: NormalizedChildren): asserts children is undefined;
+export declare function ensureTagSingleChild<TSchema extends Schema, TagName extends string>(tagName: TagName, children: NormalizedChildren, schema?: TSchema): asserts children is [ToRawElement<TSchema, TagName>];
+export declare function ensureTagSingleBlockChild(tagName: string, children: NormalizedChildren): asserts children is [BlockRawElement];
+export declare function ensureTagSingleInlinerChild(tagName: string, children: NormalizedChildren): asserts children is [InlinerRawElement];
+export declare function ensureTagChildren<TagName extends string, Schemas extends Schema | Schema[]>(tagName: TagName, children: NormalizedChildren, schemas?: Schemas): asserts children is (Schemas extends Schema[] ? ToRawElement<Schemas[number], TagName> : Schemas extends Schema ? ToRawElement<Schemas, TagName> : never)[];
+export declare function ensureTagBlockChildren(tagName: string, children: NormalizedChildren): asserts children is BlockRawElement[];
+export declare function ensureTagInlinerChildren(tagName: string, children: NormalizedChildren): asserts children is InlinerRawElement[];

package/dist/tagUtils.js

@@ -0,0 +1,62 @@
+import { TSProseError } from './error.js';
+import { ensureRawElement } from './elementUtils.js';
+export function createTagError(tagName, message) {
+    return new TSProseError(`<${tagName}> error!\n${message}`);
+}
+export function ensureTagNoChildren(tagName, children) {
+    if (children) {
+        throw createTagError(tagName, 'This tag cannot have children!');
+    }
+}
+export function ensureTagSingleChild(tagName, children, schema) {
+    if (!children || children.length !== 1) {
+        throw createTagError(tagName, 'This tag requires exactly one child element!');
+    }
+    const child = children[0];
+    ensureRawElement(child, schema);
+}
+export function ensureTagSingleBlockChild(tagName, children) {
+    ensureTagSingleChild(tagName, children);
+    if (children[0].schema.type !== 'block') {
+        throw createTagError(tagName, `This tag requires exactly one block child element but received "${children[0].schema.name}"!`);
+    }
+}
+export function ensureTagSingleInlinerChild(tagName, children) {
+    ensureTagSingleChild(tagName, children);
+    if (children[0].schema.type !== 'inliner') {
+        throw createTagError(tagName, `This tag requires exactly one inliner child element but received "${children[0].schema.name}"!`);
+    }
+}
+export function ensureTagChildren(tagName, children, schemas) {
+    if (!children) {
+        throw createTagError(tagName, 'This tag requires child elements!');
+    }
+    if (schemas) {
+        const validSchemas = new Set(schemas
+            ? Array.isArray(schemas)
+                ? schemas.map((s) => s.name)
+                : [schemas.name]
+            : undefined);
+        for (const child of children) {
+            if (!validSchemas.has(child.schema.name)) {
+                throw createTagError(tagName, `This tag cannot have "${child.schema.name}" child!`);
+            }
+        }
+    }
+}
+export function ensureTagBlockChildren(tagName, children) {
+    ensureTagChildren(tagName, children);
+    for (const child of children) {
+        if (child.schema.type !== 'block') {
+            throw createTagError(tagName, `This tag cannot have "${child.schema.name}" inliner child!`);
+        }
+    }
+}
+export function ensureTagInlinerChildren(tagName, children) {
+    ensureTagChildren(tagName, children);
+    for (const child of children) {
+        if (child.schema.type !== 'inliner') {
+            throw createTagError(tagName, `This tag cannot have "${child.schema.name}" block child!`);
+        }
+    }
+}

package/dist/unique.d.ts

@@ -0,0 +1,25 @@
+import type { ToRawElement } from './element.js';
+import type { LinkableTag } from './tag.js';
+export declare const UNIQUE_PREFIX = "__TSPROSE_unique";
+export interface ToUnique<Tag extends LinkableTag> {
+    [UNIQUE_PREFIX]: true;
+    documentId: string;
+    name: string;
+    tag: Tag;
+    rawElement: ToRawElement<Tag['schema'], Tag['tagName']>;
+}
+export type Unique = ToUnique<LinkableTag>;
+export interface AutoUnique extends Unique {
+    auto: true;
+}
+export declare function defineUnique<Tag extends LinkableTag>(uniqueParameters: {
+    documentId: string;
+    name: string;
+    tag: Tag;
+}): ToUnique<Tag>;
+export declare function defineAutoUnique(uniqueParameters: {
+    documentId: string;
+    name: string;
+}): AutoUnique;
+export declare function isUnique<Tag extends LinkableTag>(unique: any, tag?: Tag): unique is ToUnique<Tag>;
+export declare function isAutoUnique(unique: any): unique is AutoUnique;

package/dist/unique.js

@@ -0,0 +1,81 @@
+import { TSProseError } from './error.js';
+export const UNIQUE_PREFIX = '__TSPROSE_unique';
+export function defineUnique(uniqueParameters) {
+    const { documentId, name, tag } = uniqueParameters;
+    const schema = tag.schema;
+    if (!schema.linkable) {
+        throw new TSProseError(`Unable to create unique "${name}" for <${tag.tagName}> because its schema is not linkable!`);
+    }
+    let rawElement;
+    return {
+        [UNIQUE_PREFIX]: true,
+        documentId,
+        name,
+        tag,
+        get rawElement() {
+            if (!rawElement) {
+                throw new TSProseError(`Unique "${name}" raw element is not assigned yet!`);
+            }
+            return rawElement;
+        },
+        set rawElement(value) {
+            if (rawElement) {
+                throw new TSProseError(`Unique "${name}" raw element is already assigned and cannot be reassigned!`);
+            }
+            if (value.tagName !== tag.tagName) {
+                throw new TSProseError(`Unique "${name}" requires <${tag.tagName}> element but received <${value.tagName}>!`);
+            }
+            rawElement = value;
+        },
+    };
+}
+export function defineAutoUnique(uniqueParameters) {
+    const { documentId, name } = uniqueParameters;
+    let tag;
+    let rawElement;
+    return {
+        [UNIQUE_PREFIX]: true,
+        auto: true,
+        documentId,
+        name,
+        get tag() {
+            if (!tag) {
+                throw new TSProseError(`Auto unique "${name}" tag is not assigned yet!`);
+            }
+            return tag;
+        },
+        set tag(value) {
+            if (tag) {
+                throw new TSProseError(`Auto unique "${name}" tag is already assigned and cannot be reassigned!`);
+            }
+            tag = value;
+        },
+        get rawElement() {
+            if (!rawElement) {
+                throw new TSProseError(`Auto unique "${name}" raw element is not assigned yet!`);
+            }
+            return rawElement;
+        },
+        set rawElement(value) {
+            if (rawElement) {
+                throw new TSProseError(`Auto unique "${name}" raw element is already assigned and cannot be reassigned!`);
+            }
+            if (!value.schema.linkable) {
+                throw new TSProseError(`Auto unique "${name}" cannot be assigned with non-linkable <${value.tagName}>!`);
+            }
+            rawElement = value;
+        },
+    };
+}
+export function isUnique(unique, tag) {
+    if (unique?.[UNIQUE_PREFIX] === true) {
+        if (tag) {
+            return unique.tag === tag;
+        }
+        return true;
+    }
+    return false;
+}
+export function isAutoUnique(unique) {
+    return isUnique(unique) && unique.auto === true;
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare function hash(text: string, length: number): string;

package/dist/utils/hash.js

@@ -0,0 +1,13 @@
+export function hash(text, length) {
+    const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    let h = 5381;
+    for (let i = 0; i < text.length; i++) {
+        h = ((h << 5) + h + text.charCodeAt(i)) >>> 0;
+    }
+    let out = '';
+    for (let i = 0; i < length; i++) {
+        out += ALPHABET[h % 62];
+        h = ((h << 5) + h + i) >>> 0;
+    }
+    return out;
+}

package/dist/walk.d.ts

@@ -0,0 +1,13 @@
+import type { ProseElement, RawElement } from './element.js';
+export declare const WalkStop: {
+    __TSPROSE_walkStop: boolean;
+};
+export declare const WalkNoDeeper: {
+    __TSPROSE_walkNoDeeper: boolean;
+};
+export declare function isWalkStop(value: any): value is typeof WalkStop;
+export declare function isWalkNoDeeper(value: any): value is typeof WalkNoDeeper;
+export declare function walkPreSync<ElementKind extends RawElement | ProseElement>(element: ElementKind, walkStep: (element: ElementKind) => void | typeof WalkStop | typeof WalkNoDeeper): typeof WalkStop | void;
+export declare function walkPre<ElementKind extends RawElement | ProseElement>(element: ElementKind, walkStep: (element: ElementKind) => Promise<void | typeof WalkStop | typeof WalkNoDeeper>): Promise<typeof WalkStop | void>;
+export declare function walkPostSync<ElementKind extends RawElement | ProseElement, StepReturn = any>(element: ElementKind, walkStep: (element: ElementKind, childrenResults: StepReturn[]) => StepReturn | typeof WalkStop): StepReturn | typeof WalkStop;
+export declare function walkPost<ElementKind extends RawElement | ProseElement, StepReturn = any>(element: ElementKind, walkStep: (element: ElementKind, childrenResults: StepReturn[]) => Promise<StepReturn | typeof WalkStop>): Promise<StepReturn | typeof WalkStop>;