@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/code/kind.js

@@ -0,0 +1,142 @@
+//#region src/code/kind.ts
+const MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([
+	"md",
+	"mdx",
+	"markdown"
+]);
+/** Extensions of files that are not text. `svg` is not here: it is XML and opens as code. */
+const BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"avif",
+	"bmp",
+	"ico",
+	"tif",
+	"tiff",
+	"heic",
+	"heif",
+	"pdf",
+	"mp3",
+	"wav",
+	"ogg",
+	"oga",
+	"flac",
+	"m4a",
+	"aac",
+	"opus",
+	"mp4",
+	"m4v",
+	"mov",
+	"webm",
+	"mkv",
+	"avi",
+	"zip",
+	"gz",
+	"tgz",
+	"bz2",
+	"xz",
+	"zst",
+	"7z",
+	"rar",
+	"tar",
+	"doc",
+	"docx",
+	"xls",
+	"xlsx",
+	"ppt",
+	"pptx",
+	"odt",
+	"ods",
+	"odp",
+	"woff",
+	"woff2",
+	"ttf",
+	"otf",
+	"eot",
+	"wasm",
+	"exe",
+	"dll",
+	"so",
+	"dylib",
+	"bin",
+	"class",
+	"jar",
+	"sqlite",
+	"db"
+]);
+const TEXT_MIME = /^(?:text\/|application\/(?:json|xml|yaml|x-yaml|toml|javascript|typescript|x-sh|x-httpd-php|sql|graphql)\b|.+\+(?:json|xml|yaml)$)/;
+const BINARY_MIME = /^(?:image\/(?!svg\+xml)|audio\/|video\/|font\/|application\/(?:pdf|zip|gzip|x-tar|x-7z-compressed|x-rar-compressed|wasm|vnd\.openxmlformats|vnd\.ms-|msword|vnd\.oasis\.opendocument))/;
+const EXTENSION_TO_LANG = {
+	ts: "typescript",
+	mts: "typescript",
+	cts: "typescript",
+	tsx: "tsx",
+	js: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	jsx: "jsx",
+	json: "json",
+	jsonc: "json",
+	json5: "json",
+	jsonl: "jsonl",
+	ndjson: "jsonl",
+	yaml: "yaml",
+	yml: "yaml",
+	toml: "toml",
+	css: "css",
+	scss: "css",
+	less: "css",
+	html: "html",
+	htm: "html",
+	xml: "xml",
+	svg: "xml",
+	py: "python",
+	go: "go",
+	rs: "rust",
+	rb: "ruby",
+	java: "java",
+	kt: "kotlin",
+	c: "c",
+	cpp: "cpp",
+	cs: "csharp",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	sql: "sql",
+	vue: "vue",
+	md: "markdown",
+	mdx: "markdown",
+	markdown: "markdown"
+};
+function extensionOf(path) {
+	const name = path.slice(path.lastIndexOf("/") + 1);
+	const dot = name.lastIndexOf(".");
+	return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+}
+/**
+* Which surface edits `path`: the Markdown surface for `.md`/`.mdx`/`.markdown`, the code surface for any other text
+* (unknown or missing extensions are text), `binary` for images, media, archives, documents, fonts and executables.
+* An explicit `mime` of a binary type makes the file binary whatever its name; a Markdown mime makes it Markdown; a
+* text mime keeps a Markdown extension Markdown (servers answer `text/plain` for `.md`) and otherwise means code; any
+* other mime (`application/octet-stream`) defers to the extension.
+*/
+function kindOf(path, mime) {
+	const type = mime?.split(";")[0]?.trim().toLowerCase();
+	if (type === "text/markdown" || type === "text/x-markdown") return "markdown";
+	if (type && BINARY_MIME.test(type)) return "binary";
+	if (type && TEXT_MIME.test(type)) return MARKDOWN_EXTENSIONS.has(extensionOf(path)) ? "markdown" : "code";
+	const extension = extensionOf(path);
+	if (MARKDOWN_EXTENSIONS.has(extension)) return "markdown";
+	return BINARY_EXTENSIONS.has(extension) ? "binary" : "code";
+}
+/** The language id `registerLanguage` knows `path`'s extension by, or `undefined` for plain text. */
+function languageOf(path) {
+	return EXTENSION_TO_LANG[extensionOf(path)];
+}
+//#endregion
+export { kindOf, languageOf };
+
+//# sourceMappingURL=kind.js.map

package/dist/code/kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.js","names":[],"sources":["../../src/code/kind.ts"],"sourcesContent":["/** What a document is edited with: the rich Markdown surface, the code surface, or nothing this package renders. */\nexport type DocumentKind = 'markdown' | 'code' | 'binary'\n\nconst MARKDOWN_EXTENSIONS = new Set(['md', 'mdx', 'markdown'])\n\n/** Extensions of files that are not text. `svg` is not here: it is XML and opens as code. */\nconst BINARY_EXTENSIONS = new Set([\n  'png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'bmp', 'ico', 'tif', 'tiff', 'heic', 'heif',\n  'pdf',\n  'mp3', 'wav', 'ogg', 'oga', 'flac', 'm4a', 'aac', 'opus',\n  'mp4', 'm4v', 'mov', 'webm', 'mkv', 'avi',\n  'zip', 'gz', 'tgz', 'bz2', 'xz', 'zst', '7z', 'rar', 'tar',\n  'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp',\n  'woff', 'woff2', 'ttf', 'otf', 'eot',\n  'wasm', 'exe', 'dll', 'so', 'dylib', 'bin', 'class', 'jar', 'sqlite', 'db',\n])\n\nconst TEXT_MIME = /^(?:text\\/|application\\/(?:json|xml|yaml|x-yaml|toml|javascript|typescript|x-sh|x-httpd-php|sql|graphql)\\b|.+\\+(?:json|xml|yaml)$)/\nconst BINARY_MIME = /^(?:image\\/(?!svg\\+xml)|audio\\/|video\\/|font\\/|application\\/(?:pdf|zip|gzip|x-tar|x-7z-compressed|x-rar-compressed|wasm|vnd\\.openxmlformats|vnd\\.ms-|msword|vnd\\.oasis\\.opendocument))/\n\nconst EXTENSION_TO_LANG: Record<string, string> = {\n  ts: 'typescript', mts: 'typescript', cts: 'typescript', tsx: 'tsx',\n  js: 'javascript', mjs: 'javascript', cjs: 'javascript', jsx: 'jsx',\n  json: 'json', jsonc: 'json', json5: 'json', jsonl: 'jsonl', ndjson: 'jsonl',\n  yaml: 'yaml', yml: 'yaml', toml: 'toml',\n  css: 'css', scss: 'css', less: 'css',\n  html: 'html', htm: 'html', xml: 'xml', svg: 'xml',\n  py: 'python', go: 'go', rs: 'rust', rb: 'ruby', java: 'java', kt: 'kotlin', c: 'c', cpp: 'cpp', cs: 'csharp',\n  sh: 'bash', bash: 'bash', zsh: 'bash',\n  sql: 'sql', vue: 'vue',\n  md: 'markdown', mdx: 'markdown', markdown: 'markdown',\n}\n\nfunction extensionOf(path: string): string {\n  const name = path.slice(path.lastIndexOf('/') + 1)\n  const dot = name.lastIndexOf('.')\n  // A leading dot is a hidden file's name (`.env`), not an extension.\n  return dot > 0 ? name.slice(dot + 1).toLowerCase() : ''\n}\n\n/**\n * Which surface edits `path`: the Markdown surface for `.md`/`.mdx`/`.markdown`, the code surface for any other text\n * (unknown or missing extensions are text), `binary` for images, media, archives, documents, fonts and executables.\n * An explicit `mime` of a binary type makes the file binary whatever its name; a Markdown mime makes it Markdown; a\n * text mime keeps a Markdown extension Markdown (servers answer `text/plain` for `.md`) and otherwise means code; any\n * other mime (`application/octet-stream`) defers to the extension.\n */\nexport function kindOf(path: string, mime?: string): DocumentKind {\n  const type = mime?.split(';')[0]?.trim().toLowerCase()\n  if (type === 'text/markdown' || type === 'text/x-markdown') return 'markdown'\n  if (type && BINARY_MIME.test(type)) return 'binary'\n  if (type && TEXT_MIME.test(type)) return MARKDOWN_EXTENSIONS.has(extensionOf(path)) ? 'markdown' : 'code'\n  const extension = extensionOf(path)\n  if (MARKDOWN_EXTENSIONS.has(extension)) return 'markdown'\n  return BINARY_EXTENSIONS.has(extension) ? 'binary' : 'code'\n}\n\n/** The language id `registerLanguage` knows `path`'s extension by, or `undefined` for plain text. */\nexport function languageOf(path: string): string | undefined {\n  return EXTENSION_TO_LANG[extensionOf(path)]\n}\n"],"mappings":";AAGA,MAAM,sCAAsB,IAAI,IAAI;CAAC;CAAM;CAAO;AAAU,CAAC;;AAG7D,MAAM,oCAAoB,IAAI,IAAI;CAChC;CAAO;CAAO;CAAQ;CAAO;CAAQ;CAAQ;CAAO;CAAO;CAAO;CAAQ;CAAQ;CAClF;CACA;CAAO;CAAO;CAAO;CAAO;CAAQ;CAAO;CAAO;CAClD;CAAO;CAAO;CAAO;CAAQ;CAAO;CACpC;CAAO;CAAM;CAAO;CAAO;CAAM;CAAO;CAAM;CAAO;CACrD;CAAO;CAAQ;CAAO;CAAQ;CAAO;CAAQ;CAAO;CAAO;CAC3D;CAAQ;CAAS;CAAO;CAAO;CAC/B;CAAQ;CAAO;CAAO;CAAM;CAAS;CAAO;CAAS;CAAO;CAAU;AACxE,CAAC;AAED,MAAM,YAAY;AAClB,MAAM,cAAc;AAEpB,MAAM,oBAA4C;CAChD,IAAI;CAAc,KAAK;CAAc,KAAK;CAAc,KAAK;CAC7D,IAAI;CAAc,KAAK;CAAc,KAAK;CAAc,KAAK;CAC7D,MAAM;CAAQ,OAAO;CAAQ,OAAO;CAAQ,OAAO;CAAS,QAAQ;CACpE,MAAM;CAAQ,KAAK;CAAQ,MAAM;CACjC,KAAK;CAAO,MAAM;CAAO,MAAM;CAC/B,MAAM;CAAQ,KAAK;CAAQ,KAAK;CAAO,KAAK;CAC5C,IAAI;CAAU,IAAI;CAAM,IAAI;CAAQ,IAAI;CAAQ,MAAM;CAAQ,IAAI;CAAU,GAAG;CAAK,KAAK;CAAO,IAAI;CACpG,IAAI;CAAQ,MAAM;CAAQ,KAAK;CAC/B,KAAK;CAAO,KAAK;CACjB,IAAI;CAAY,KAAK;CAAY,UAAU;AAC7C;AAEA,SAAS,YAAY,MAAsB;CACzC,MAAM,OAAO,KAAK,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC;CACjD,MAAM,MAAM,KAAK,YAAY,GAAG;CAEhC,OAAO,MAAM,IAAI,KAAK,MAAM,MAAM,CAAC,CAAC,CAAC,YAAY,IAAI;AACvD;;;;;;;;AASA,SAAgB,OAAO,MAAc,MAA6B;CAChE,MAAM,OAAO,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,YAAY;CACrD,IAAI,SAAS,mBAAmB,SAAS,mBAAmB,OAAO;CACnE,IAAI,QAAQ,YAAY,KAAK,IAAI,GAAG,OAAO;CAC3C,IAAI,QAAQ,UAAU,KAAK,IAAI,GAAG,OAAO,oBAAoB,IAAI,YAAY,IAAI,CAAC,IAAI,aAAa;CACnG,MAAM,YAAY,YAAY,IAAI;CAClC,IAAI,oBAAoB,IAAI,SAAS,GAAG,OAAO;CAC/C,OAAO,kBAAkB,IAAI,SAAS,IAAI,WAAW;AACvD;;AAGA,SAAgB,WAAW,MAAkC;CAC3D,OAAO,kBAAkB,YAAY,IAAI;AAC3C"}

package/dist/code/lang-registry.d.ts

@@ -0,0 +1,31 @@
+import { LanguageSupport } from "@codemirror/language";
+//#region src/code/lang-registry.d.ts
+/**
+ * Builds a language pack. Synchronous for packs the host bundles up front, asynchronous (`import()`) for packs it loads
+ * on demand; the host's bundler splits on its own literal `import()` specifiers.
+ */
+export type LanguageLoader = () => LanguageSupport | Promise<LanguageSupport>;
+export interface RegisterLanguageOptions {
+  /**
+   * The loader is synchronous and cheap: the language is available without a network round trip, `isCoreLang(id)` is
+   * true and a surface may mount with it highlighted from the first frame. Default false.
+   */
+  core?: boolean;
+}
+/**
+ * Makes `id` (a value of `languageOf(path)` or a host's own) resolvable. The package ships no language packs apart from
+ * JSON Lines: the host depends on the `@codemirror/lang-*` packs it needs and registers them once at startup, e.g.
+ * `registerLanguage('typescript', async () => (await import('@codemirror/lang-javascript')).javascript({ jsx: true, typescript: true }))`.
+ * Registering an id again replaces the earlier pack.
+ */
+export declare function registerLanguage(id: string, load: LanguageLoader, options?: RegisterLanguageOptions): void;
+/**
+ * Resolves a language id to its `LanguageSupport`, loading it on first use and caching it. `null` for an id nobody
+ * registered and for a pack that failed to load: the caller mounts without a language, which still gives line numbers,
+ * monospace text and search. A failed load is not cached, the next call tries again.
+ */
+export declare function resolveLanguage(id: string): Promise<LanguageSupport | null>;
+/** Whether `id` was registered as a core language (synchronous, always available without loading anything). */
+export declare function isCoreLang(id: string): boolean;
+//#endregion
+//# sourceMappingURL=lang-registry.d.ts.map

package/dist/code/lang-registry.js

@@ -0,0 +1,54 @@
+import { jsonl } from "./jsonl-language.js";
+//#region src/code/lang-registry.ts
+const registrations = /* @__PURE__ */ new Map();
+const resolved = /* @__PURE__ */ new Map();
+const pending = /* @__PURE__ */ new Map();
+/**
+* Makes `id` (a value of `languageOf(path)` or a host's own) resolvable. The package ships no language packs apart from
+* JSON Lines: the host depends on the `@codemirror/lang-*` packs it needs and registers them once at startup, e.g.
+* `registerLanguage('typescript', async () => (await import('@codemirror/lang-javascript')).javascript({ jsx: true, typescript: true }))`.
+* Registering an id again replaces the earlier pack.
+*/
+function registerLanguage(id, load, options = {}) {
+	registrations.set(id, {
+		load,
+		core: options.core ?? false
+	});
+	resolved.delete(id);
+	pending.delete(id);
+}
+/**
+* Resolves a language id to its `LanguageSupport`, loading it on first use and caching it. `null` for an id nobody
+* registered and for a pack that failed to load: the caller mounts without a language, which still gives line numbers,
+* monospace text and search. A failed load is not cached, the next call tries again.
+*/
+async function resolveLanguage(id) {
+	const known = resolved.get(id);
+	if (known) return known;
+	const running = pending.get(id);
+	if (running) return running;
+	const registration = registrations.get(id);
+	if (!registration) return null;
+	const run = (async () => {
+		try {
+			const support = await registration.load();
+			if (registrations.get(id) === registration) resolved.set(id, support);
+			return support;
+		} catch {
+			return null;
+		}
+	})().finally(() => {
+		if (pending.get(id) === run) pending.delete(id);
+	});
+	pending.set(id, run);
+	return run;
+}
+/** Whether `id` was registered as a core language (synchronous, always available without loading anything). */
+function isCoreLang(id) {
+	return registrations.get(id)?.core ?? false;
+}
+registerLanguage("jsonl", jsonl, { core: true });
+//#endregion
+export { isCoreLang, registerLanguage, resolveLanguage };
+
+//# sourceMappingURL=lang-registry.js.map

package/dist/code/lang-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang-registry.js","names":[],"sources":["../../src/code/lang-registry.ts"],"sourcesContent":["import type { LanguageSupport } from '@codemirror/language'\nimport { jsonl } from './jsonl-language'\n\n/**\n * Builds a language pack. Synchronous for packs the host bundles up front, asynchronous (`import()`) for packs it loads\n * on demand; the host's bundler splits on its own literal `import()` specifiers.\n */\nexport type LanguageLoader = () => LanguageSupport | Promise<LanguageSupport>\n\nexport interface RegisterLanguageOptions {\n  /**\n   * The loader is synchronous and cheap: the language is available without a network round trip, `isCoreLang(id)` is\n   * true and a surface may mount with it highlighted from the first frame. Default false.\n   */\n  core?: boolean\n}\n\ninterface Registration {\n  load: LanguageLoader\n  core: boolean\n}\n\nconst registrations = new Map<string, Registration>()\nconst resolved = new Map<string, LanguageSupport>()\nconst pending = new Map<string, Promise<LanguageSupport | null>>()\n\n/**\n * Makes `id` (a value of `languageOf(path)` or a host's own) resolvable. The package ships no language packs apart from\n * JSON Lines: the host depends on the `@codemirror/lang-*` packs it needs and registers them once at startup, e.g.\n * `registerLanguage('typescript', async () => (await import('@codemirror/lang-javascript')).javascript({ jsx: true, typescript: true }))`.\n * Registering an id again replaces the earlier pack.\n */\nexport function registerLanguage(id: string, load: LanguageLoader, options: RegisterLanguageOptions = {}): void {\n  registrations.set(id, { load, core: options.core ?? false })\n  resolved.delete(id)\n  pending.delete(id)\n}\n\n/**\n * Resolves a language id to its `LanguageSupport`, loading it on first use and caching it. `null` for an id nobody\n * registered and for a pack that failed to load: the caller mounts without a language, which still gives line numbers,\n * monospace text and search. A failed load is not cached, the next call tries again.\n */\nexport async function resolveLanguage(id: string): Promise<LanguageSupport | null> {\n  const known = resolved.get(id)\n  if (known) return known\n  const running = pending.get(id)\n  if (running) return running\n  const registration = registrations.get(id)\n  if (!registration) return null\n  const run: Promise<LanguageSupport | null> = (async () => {\n    try {\n      const support = await registration.load()\n      // Registered anew while loading: this result belongs to the replaced pack.\n      if (registrations.get(id) === registration) resolved.set(id, support)\n      return support\n    }\n    catch {\n      return null\n    }\n  })().finally(() => {\n    if (pending.get(id) === run) pending.delete(id)\n  })\n  pending.set(id, run)\n  return run\n}\n\n/** Whether `id` was registered as a core language (synchronous, always available without loading anything). */\nexport function isCoreLang(id: string): boolean {\n  return registrations.get(id)?.core ?? false\n}\n\n// JSON Lines is the package's own language (a stream tokenizer over `@codemirror/language`, no pack needed).\nregisterLanguage('jsonl', jsonl, { core: true })\n"],"mappings":";;AAsBA,MAAM,gCAAgB,IAAI,IAA0B;AACpD,MAAM,2BAAW,IAAI,IAA6B;AAClD,MAAM,0BAAU,IAAI,IAA6C;;;;;;;AAQjE,SAAgB,iBAAiB,IAAY,MAAsB,UAAmC,CAAC,GAAS;CAC9G,cAAc,IAAI,IAAI;EAAE;EAAM,MAAM,QAAQ,QAAQ;CAAM,CAAC;CAC3D,SAAS,OAAO,EAAE;CAClB,QAAQ,OAAO,EAAE;AACnB;;;;;;AAOA,eAAsB,gBAAgB,IAA6C;CACjF,MAAM,QAAQ,SAAS,IAAI,EAAE;CAC7B,IAAI,OAAO,OAAO;CAClB,MAAM,UAAU,QAAQ,IAAI,EAAE;CAC9B,IAAI,SAAS,OAAO;CACpB,MAAM,eAAe,cAAc,IAAI,EAAE;CACzC,IAAI,CAAC,cAAc,OAAO;CAC1B,MAAM,OAAwC,YAAY;EACxD,IAAI;GACF,MAAM,UAAU,MAAM,aAAa,KAAK;GAExC,IAAI,cAAc,IAAI,EAAE,MAAM,cAAc,SAAS,IAAI,IAAI,OAAO;GACpE,OAAO;EACT,QACM;GACJ,OAAO;EACT;CACF,EAAA,CAAG,CAAC,CAAC,cAAc;EACjB,IAAI,QAAQ,IAAI,EAAE,MAAM,KAAK,QAAQ,OAAO,EAAE;CAChD,CAAC;CACD,QAAQ,IAAI,IAAI,GAAG;CACnB,OAAO;AACT;;AAGA,SAAgB,WAAW,IAAqB;CAC9C,OAAO,cAAc,IAAI,EAAE,CAAC,EAAE,QAAQ;AACxC;AAGA,iBAAiB,SAAS,OAAO,EAAE,MAAM,KAAK,CAAC"}

package/dist/code/react.d.ts

@@ -0,0 +1,2 @@
+import { CodeSurface, CodeSurfaceHandle, CodeSurfaceProps } from "./CodeSurface.js";
+export { CodeSurface, type CodeSurfaceHandle, type CodeSurfaceProps };

package/dist/code/react.js

@@ -0,0 +1 @@
+export { CodeSurface } from "./CodeSurface.js";

package/dist/code/vue.d.ts

@@ -0,0 +1,2 @@
+import _default from "./CodeSurface.vue.js";
+export { _default as CodeSurface };

package/dist/code/vue.js

@@ -0,0 +1 @@
+export { default as CodeSurface } from "./CodeSurface2.js";

package/dist/core/abilities.d.ts

@@ -0,0 +1,32 @@
+import { Ability, AbilityRuleSource } from "./schema/abilities.js";
+import { AbilitiesOptions } from "./extension-points.js";
+import { Editor, Extension } from "@tiptap/core";
+import { Node as Node$1, ResolvedPos } from "@tiptap/pm/model";
+//#region src/core/abilities.d.ts
+export interface AbilitiesStorage {
+  rules: Map<string, AbilityRuleSource>;
+  root: readonly Ability[];
+}
+declare module '@tiptap/core' {
+  interface Storage {
+    abilities: AbilitiesStorage;
+  }
+}
+/** Rules for StarterKit/extension nodes that cannot carry `NodeConfig.abilities` themselves. */
+export declare const DEFAULT_ABILITY_RULES: Record<string, AbilityRuleSource>;
+/**
+ * Abilities at `pos`: chain = ancestors at depth 1…depth, plus `node` when given (an atom starting at `pos`).
+ * A `ResolvedPos` addresses a document other than `editor.state.doc`, e.g. a transaction's doc inside plugin `apply`.
+ */
+export declare function abilitiesAt(editor: Editor, pos: number | ResolvedPos, node?: Node$1): ReadonlySet<Ability>;
+/** Abilities of the selection: the selected node, or what both ends of a range allow. */
+export declare function abilitiesAtSelection(editor: Editor): ReadonlySet<Ability>;
+export declare function hasAbility(editor: Editor, ability: Ability): boolean;
+/**
+ * Hierarchical abilities (see shared/editor/abilities.ts). Resolution reads `editor.storage.abilities`; the plugin
+ * swallows `Mod-`/`Alt-` shortcuts and pre-empts input rules of node/mark types whose ability is missing at the caret.
+ * Paste, drop and remote changes are not filtered.
+ */
+export declare const Abilities: Extension<AbilitiesOptions, AbilitiesStorage>;
+//#endregion
+//# sourceMappingURL=abilities.d.ts.map

package/dist/core/abilities.js

@@ -0,0 +1,160 @@
+import { ABILITY, ROOT_ABILITIES, TEXT_ABILITIES, TYPE_ABILITIES, resolveAbilities } from "./schema/abilities.js";
+import { Extension, getExtensionField } from "@tiptap/core";
+import { keydownHandler } from "@tiptap/pm/keymap";
+import { NodeSelection, Plugin, PluginKey } from "@tiptap/pm/state";
+//#region src/core/abilities.ts
+/** Rules for StarterKit/extension nodes that cannot carry `NodeConfig.abilities` themselves. */
+const DEFAULT_ABILITY_RULES = {
+	codeBlock: { revokes: [
+		ABILITY.marks,
+		ABILITY.headings,
+		ABILITY.lists,
+		ABILITY.blockquote,
+		ABILITY.rule,
+		ABILITY.blockContent,
+		ABILITY.composite,
+		ABILITY.transcript,
+		ABILITY.media,
+		ABILITY.record,
+		ABILITY.mention,
+		ABILITY.tag,
+		ABILITY.aiAutocomplete
+	] },
+	image: { revokes: TEXT_ABILITIES },
+	horizontalRule: { revokes: TEXT_ABILITIES }
+};
+/**
+* Abilities at `pos`: chain = ancestors at depth 1…depth, plus `node` when given (an atom starting at `pos`).
+* A `ResolvedPos` addresses a document other than `editor.state.doc`, e.g. a transaction's doc inside plugin `apply`.
+*/
+function abilitiesAt(editor, pos, node) {
+	const $pos = typeof pos === "number" ? editor.state.doc.resolve(pos) : pos;
+	const chain = [];
+	for (let depth = 1; depth <= $pos.depth; depth++) chain.push($pos.node(depth));
+	if (node) chain.push(node);
+	const { rules, root } = editor.storage.abilities;
+	return resolveAbilities(rules, root, chain);
+}
+/** Abilities of the selection: the selected node, or what both ends of a range allow. */
+function abilitiesAtSelection(editor) {
+	const { selection } = editor.state;
+	if (selection instanceof NodeSelection) return abilitiesAt(editor, selection.from, selection.node);
+	const from = abilitiesAt(editor, selection.$from.pos);
+	if (selection.empty) return from;
+	const to = abilitiesAt(editor, selection.$to.pos);
+	return new Set([...from].filter((ability) => to.has(ability)));
+}
+function hasAbility(editor, ability) {
+	return abilitiesAtSelection(editor).has(ability);
+}
+/** Only modifier shortcuts are gated; plain Enter/Tab/Backspace keep their structural behaviour everywhere. */
+const GATED_KEY = /(^|-)(Mod|Alt)-/;
+/** How much text before the caret input rules get to see (mirrors TipTap's input-rule plugin). */
+const MAX_MATCH = 500;
+/** Same `this` the ExtensionManager hands to `addKeyboardShortcuts` / `addInputRules` (core dist, `get plugins()`). */
+function extensionContext(ext, editor) {
+	return {
+		name: ext.name,
+		options: ext.options,
+		storage: editor.extensionStorage[ext.name],
+		editor,
+		type: editor.schema.nodes[ext.name] ?? editor.schema.marks[ext.name] ?? null
+	};
+}
+function gatedExtensions(editor) {
+	return editor.extensionManager.extensions.flatMap((ext) => {
+		const ability = TYPE_ABILITIES[ext.name];
+		return ability ? [[ext, ability]] : [];
+	});
+}
+function buildKeyBindings(editor) {
+	const abilitiesByKey = /* @__PURE__ */ new Map();
+	for (const [ext, ability] of gatedExtensions(editor)) {
+		const addKeyboardShortcuts = getExtensionField(ext, "addKeyboardShortcuts", extensionContext(ext, editor));
+		for (const key of Object.keys(addKeyboardShortcuts?.() ?? {})) {
+			if (!GATED_KEY.test(key)) continue;
+			abilitiesByKey.set(key, [...abilitiesByKey.get(key) ?? [], ability]);
+		}
+	}
+	return Object.fromEntries([...abilitiesByKey].map(([key, abilities]) => [key, () => {
+		const present = abilitiesAtSelection(editor);
+		return abilities.some((ability) => !present.has(ability));
+	}]));
+}
+function buildInputRules(editor) {
+	return gatedExtensions(editor).flatMap(([ext, ability]) => {
+		return (getExtensionField(ext, "addInputRules", extensionContext(ext, editor))?.() ?? []).map((rule) => ({
+			find: rule.find,
+			ability
+		}));
+	});
+}
+function matches(find, text) {
+	if (typeof find === "function") return find(text) != null;
+	find.lastIndex = 0;
+	return find.exec(text) !== null;
+}
+/**
+* Hierarchical abilities (see shared/editor/abilities.ts). Resolution reads `editor.storage.abilities`; the plugin
+* swallows `Mod-`/`Alt-` shortcuts and pre-empts input rules of node/mark types whose ability is missing at the caret.
+* Paste, drop and remote changes are not filtered.
+*/
+const Abilities = Extension.create({
+	name: "abilities",
+	priority: 1e3,
+	addOptions() {
+		return {
+			root: ROOT_ABILITIES,
+			rules: DEFAULT_ABILITY_RULES
+		};
+	},
+	addStorage() {
+		return {
+			rules: /* @__PURE__ */ new Map(),
+			root: this.options.root
+		};
+	},
+	onBeforeCreate() {
+		const rules = /* @__PURE__ */ new Map();
+		for (const ext of this.editor.extensionManager.extensions) {
+			const rule = getExtensionField(ext, "abilities");
+			if (rule) rules.set(ext.name, rule);
+		}
+		for (const [name, rule] of Object.entries(this.options.rules)) rules.set(name, rule);
+		this.storage.rules = rules;
+		this.storage.root = this.options.root;
+	},
+	addProseMirrorPlugins() {
+		const editor = this.editor;
+		let handleKey;
+		let inputRules;
+		return [new Plugin({
+			key: new PluginKey("abilities"),
+			props: {
+				handleKeyDown(view, event) {
+					handleKey ??= keydownHandler(buildKeyBindings(editor));
+					return handleKey(view, event);
+				},
+				handleTextInput(view, from, to, text) {
+					inputRules ??= buildInputRules(editor);
+					if (!inputRules.length) return false;
+					const $from = view.state.doc.resolve(from);
+					if (!$from.parent.isTextblock) return false;
+					const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, void 0, "") + text;
+					let present;
+					for (const rule of inputRules) {
+						present ??= abilitiesAt(editor, from);
+						if (present.has(rule.ability) || !matches(rule.find, textBefore)) continue;
+						view.dispatch(view.state.tr.insertText(text, from, to));
+						return true;
+					}
+					return false;
+				}
+			}
+		})];
+	}
+});
+//#endregion
+export { Abilities, DEFAULT_ABILITY_RULES, abilitiesAt, abilitiesAtSelection, hasAbility };
+
+//# sourceMappingURL=abilities.js.map

package/dist/core/abilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abilities.js","names":[],"sources":["../../src/core/abilities.ts"],"sourcesContent":["import { type AnyExtension, type Editor, Extension, getExtensionField, type InputRule, type KeyboardShortcutCommand } from '@tiptap/core'\nimport { keydownHandler } from '@tiptap/pm/keymap'\nimport type { Node as PMNode, ResolvedPos } from '@tiptap/pm/model'\nimport { NodeSelection, Plugin, PluginKey } from '@tiptap/pm/state'\nimport type { EditorView } from '@tiptap/pm/view'\nimport {\n  ABILITY,\n  type Ability,\n  type AbilityRuleSource,\n  resolveAbilities,\n  ROOT_ABILITIES,\n  TEXT_ABILITIES,\n  TYPE_ABILITIES,\n} from './schema/abilities'\nimport type { AbilitiesOptions } from './extension-points'\n\nexport interface AbilitiesStorage {\n  rules: Map<string, AbilityRuleSource>\n  root: readonly Ability[]\n}\n\ndeclare module '@tiptap/core' {\n  interface Storage {\n    abilities: AbilitiesStorage\n  }\n}\n\n/** Rules for StarterKit/extension nodes that cannot carry `NodeConfig.abilities` themselves. */\nexport const DEFAULT_ABILITY_RULES: Record<string, AbilityRuleSource> = {\n  codeBlock: {\n    revokes: [\n      ABILITY.marks, ABILITY.headings, ABILITY.lists, ABILITY.blockquote, ABILITY.rule, ABILITY.blockContent, ABILITY.composite, ABILITY.transcript,\n      ABILITY.media, ABILITY.record, ABILITY.mention, ABILITY.tag, ABILITY.aiAutocomplete,\n    ],\n  },\n  image: { revokes: TEXT_ABILITIES },\n  horizontalRule: { revokes: TEXT_ABILITIES },\n}\n\n/**\n * Abilities at `pos`: chain = ancestors at depth 1…depth, plus `node` when given (an atom starting at `pos`).\n * A `ResolvedPos` addresses a document other than `editor.state.doc`, e.g. a transaction's doc inside plugin `apply`.\n */\nexport function abilitiesAt(editor: Editor, pos: number | ResolvedPos, node?: PMNode): ReadonlySet<Ability> {\n  const $pos = typeof pos === 'number' ? editor.state.doc.resolve(pos) : pos\n  const chain: PMNode[] = []\n  for (let depth = 1; depth <= $pos.depth; depth++) chain.push($pos.node(depth))\n  if (node) chain.push(node)\n  const { rules, root } = editor.storage.abilities\n  return resolveAbilities(rules, root, chain)\n}\n\n/** Abilities of the selection: the selected node, or what both ends of a range allow. */\nexport function abilitiesAtSelection(editor: Editor): ReadonlySet<Ability> {\n  const { selection } = editor.state\n  if (selection instanceof NodeSelection) return abilitiesAt(editor, selection.from, selection.node)\n  const from = abilitiesAt(editor, selection.$from.pos)\n  if (selection.empty) return from\n  const to = abilitiesAt(editor, selection.$to.pos)\n  return new Set([...from].filter(ability => to.has(ability)))\n}\n\nexport function hasAbility(editor: Editor, ability: Ability): boolean {\n  return abilitiesAtSelection(editor).has(ability)\n}\n\n/** Only modifier shortcuts are gated; plain Enter/Tab/Backspace keep their structural behaviour everywhere. */\nconst GATED_KEY = /(^|-)(Mod|Alt)-/\n/** How much text before the caret input rules get to see (mirrors TipTap's input-rule plugin). */\nconst MAX_MATCH = 500\n\ninterface GatedInputRule {\n  find: InputRule['find']\n  ability: Ability\n}\n\n/** Same `this` the ExtensionManager hands to `addKeyboardShortcuts` / `addInputRules` (core dist, `get plugins()`). */\nfunction extensionContext(ext: AnyExtension, editor: Editor) {\n  return {\n    name: ext.name,\n    options: ext.options,\n    storage: editor.extensionStorage[ext.name as keyof typeof editor.extensionStorage],\n    editor,\n    type: editor.schema.nodes[ext.name] ?? editor.schema.marks[ext.name] ?? null,\n  }\n}\n\nfunction gatedExtensions(editor: Editor): [AnyExtension, Ability][] {\n  return editor.extensionManager.extensions.flatMap((ext): [AnyExtension, Ability][] => {\n    const ability = TYPE_ABILITIES[ext.name]\n    return ability ? [[ext, ability]] : []\n  })\n}\n\nfunction buildKeyBindings(editor: Editor) {\n  const abilitiesByKey = new Map<string, Ability[]>()\n  for (const [ext, ability] of gatedExtensions(editor)) {\n    const addKeyboardShortcuts = getExtensionField<(() => Record<string, KeyboardShortcutCommand>) | undefined>(\n      ext, 'addKeyboardShortcuts', extensionContext(ext, editor),\n    )\n    for (const key of Object.keys(addKeyboardShortcuts?.() ?? {})) {\n      if (!GATED_KEY.test(key)) continue\n      abilitiesByKey.set(key, [...(abilitiesByKey.get(key) ?? []), ability])\n    }\n  }\n  // Returning true swallows the key, so the type's own binding never runs.\n  return Object.fromEntries([...abilitiesByKey].map(([key, abilities]) => [\n    key,\n    () => {\n      const present = abilitiesAtSelection(editor)\n      return abilities.some(ability => !present.has(ability))\n    },\n  ]))\n}\n\nfunction buildInputRules(editor: Editor): GatedInputRule[] {\n  return gatedExtensions(editor).flatMap(([ext, ability]) => {\n    const addInputRules = getExtensionField<(() => InputRule[]) | undefined>(ext, 'addInputRules', extensionContext(ext, editor))\n    return (addInputRules?.() ?? []).map(rule => ({ find: rule.find, ability }))\n  })\n}\n\nfunction matches(find: InputRule['find'], text: string): boolean {\n  if (typeof find === 'function') return find(text) != null\n  find.lastIndex = 0\n  return find.exec(text) !== null\n}\n\n/**\n * Hierarchical abilities (see shared/editor/abilities.ts). Resolution reads `editor.storage.abilities`; the plugin\n * swallows `Mod-`/`Alt-` shortcuts and pre-empts input rules of node/mark types whose ability is missing at the caret.\n * Paste, drop and remote changes are not filtered.\n */\nexport const Abilities = Extension.create<AbilitiesOptions, AbilitiesStorage>({\n  name: 'abilities',\n  // Highest priority: its plugin's handleKeyDown / handleTextInput run before the gated types' keymaps and input rules.\n  priority: 1000,\n\n  addOptions() {\n    return { root: ROOT_ABILITIES, rules: DEFAULT_ABILITY_RULES }\n  },\n\n  addStorage() {\n    return { rules: new Map(), root: this.options.root }\n  },\n\n  onBeforeCreate() {\n    const rules = new Map<string, AbilityRuleSource>()\n    for (const ext of this.editor.extensionManager.extensions) {\n      const rule = getExtensionField<AbilityRuleSource | undefined>(ext, 'abilities')\n      if (rule) rules.set(ext.name, rule)\n    }\n    // Host/default rules replace a node's own rule as a whole.\n    for (const [name, rule] of Object.entries(this.options.rules)) rules.set(name, rule)\n    this.storage.rules = rules\n    this.storage.root = this.options.root\n  },\n\n  addProseMirrorPlugins() {\n    const editor = this.editor\n    // Built lazily on first use, once per plugin: needs the final extension list and schema.\n    let handleKey: ((view: EditorView, event: KeyboardEvent) => boolean) | undefined\n    let inputRules: GatedInputRule[] | undefined\n\n    return [\n      new Plugin({\n        key: new PluginKey('abilities'),\n        props: {\n          handleKeyDown(view, event) {\n            handleKey ??= keydownHandler(buildKeyBindings(editor))\n            return handleKey(view, event)\n          },\n          handleTextInput(view, from, to, text) {\n            inputRules ??= buildInputRules(editor)\n            if (!inputRules.length) return false\n            const $from = view.state.doc.resolve(from)\n            if (!$from.parent.isTextblock) return false\n            const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, undefined, '\\ufffc') + text\n            let present: ReadonlySet<Ability> | undefined\n            for (const rule of inputRules) {\n              present ??= abilitiesAt(editor, from)\n              if (present.has(rule.ability) || !matches(rule.find, textBefore)) continue\n              // Type the character literally; the rule's own plugin never sees this input.\n              view.dispatch(view.state.tr.insertText(text, from, to))\n              return true\n            }\n            return false\n          },\n        },\n      }),\n    ]\n  },\n})\n"],"mappings":"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"}

package/dist/core/block-convert.d.ts

@@ -0,0 +1,59 @@
+import { MenuItem } from "./toolbar.js";
+import { BlockTarget } from "./extension-points.js";
+import { ConvertTarget } from "./convert.js";
+import { Translate } from "../i18n/index.js";
+import { ConversionProvider } from "./feature.js";
+import { Editor, Extension } from "@tiptap/core";
+import { EditorState } from "@tiptap/pm/state";
+import { Node as Node$1, ResolvedPos } from "@tiptap/pm/model";
+//#region src/core/block-convert.d.ts
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    blockConvert: {
+      /**
+       * Convert the block at `pos` (default: the caret's block in the document or another block container; a chrome
+       * node stands for its parent) into `target`. False when the conversion changes nothing or is impossible there.
+       */
+      convertBlockTo: (target: ConvertTarget, pos?: number) => ReturnType;
+    };
+  }
+}
+/**
+ * The standard conversions: paragraphs, headings, lists, quotes and code blocks into each other. Declines every other
+ * target, so features that add targets (speaker segments, composites) own them in their own providers.
+ */
+export declare const coreConversions: ConversionProvider;
+/** The provider that owns `target`: the first, in feature order, that parses its id. */
+export declare function targetOwner(providers: readonly ConversionProvider[], target: ConvertTarget): ConversionProvider | undefined;
+/** The target `id` names, by its owner; null when no provider knows it. */
+export declare function parseConversionTarget(providers: readonly ConversionProvider[], id: string): ConvertTarget | null;
+/** Label (in the language of `t`) and icon of `target`, from its owner. */
+export declare function conversionLabel(providers: readonly ConversionProvider[], target: ConvertTarget, t: Translate): {
+  label: string;
+  icon: string;
+};
+/** The targets offered for `node` per provider, in feature order; a target id offered twice is an error. */
+export declare function conversionTargetGroups(providers: readonly ConversionProvider[], editor: Editor, node: Node$1): ConvertTarget[][];
+/**
+ * The conversion of the block right after `$start` into `target`: the range it replaces and the converted blocks.
+ * A provider claiming the source block (`handlesSource`) executes; otherwise the target's owner does. Null when the
+ * conversion changes nothing or the result does not fit there (`parent.canReplace`). Shared by `convertBlockTo` and
+ * the chat's `convert` op.
+ */
+export declare function blockConversion(providers: readonly ConversionProvider[], state: EditorState, $start: ResolvedPos, target: ConvertTarget): {
+  from: number;
+  to: number;
+  blocks: Node$1[];
+} | null;
+/**
+ * Client-only, no schema: the `convertBlockTo` command over the preset's conversion providers — the „Umwandeln in …“
+ * block action and the toolbar's conversion groups. One transaction, so one undo step.
+ */
+export declare const BlockConvert: Extension<any, any>;
+/**
+ * „Umwandeln in …“ entries for the block `target`: the targets the providers offer whose type the block's container
+ * allows (`TYPE_ABILITIES`), one separated group per provider in feature order. A list item stands for its list.
+ */
+export declare function convertMenuItems(editor: Editor, target: BlockTarget, t: Translate): MenuItem[];
+//#endregion
+//# sourceMappingURL=block-convert.d.ts.map