@ecsplico/editor 0.0.0-stage → 2.0.0

package/dist/code/compartments.js

@@ -0,0 +1,19 @@
+import { Compartment } from "@codemirror/state";
+//#region src/code/compartments.ts
+/**
+* Compartments allow live reconfiguration of specific extension slots without tearing down the `EditorState`. Each one
+* owns one toggleable slice:
+*
+* - `readOnlyCompartment`: `EditorState.readOnly` + `EditorView.editable`
+* - `languageCompartment`: the active `LanguageSupport` (swapped when a language resolves)
+* - `wrapCompartment`: `EditorView.lineWrapping` (or nothing)
+*
+* A compartment is a key, not state: one instance serves every view.
+*/
+const readOnlyCompartment = new Compartment();
+const languageCompartment = new Compartment();
+const wrapCompartment = new Compartment();
+//#endregion
+export { languageCompartment, readOnlyCompartment, wrapCompartment };
+
+//# sourceMappingURL=compartments.js.map

package/dist/code/compartments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compartments.js","names":[],"sources":["../../src/code/compartments.ts"],"sourcesContent":["import { Compartment } from '@codemirror/state'\n\n/**\n * Compartments allow live reconfiguration of specific extension slots without tearing down the `EditorState`. Each one\n * owns one toggleable slice:\n *\n * - `readOnlyCompartment`: `EditorState.readOnly` + `EditorView.editable`\n * - `languageCompartment`: the active `LanguageSupport` (swapped when a language resolves)\n * - `wrapCompartment`: `EditorView.lineWrapping` (or nothing)\n *\n * A compartment is a key, not state: one instance serves every view.\n */\nexport const readOnlyCompartment = new Compartment()\nexport const languageCompartment = new Compartment()\nexport const wrapCompartment = new Compartment()\n"],"mappings":";;;;;;;;;;;;AAYA,MAAa,sBAAsB,IAAI,YAAY;AACnD,MAAa,sBAAsB,IAAI,YAAY;AACnD,MAAa,kBAAkB,IAAI,YAAY"}

package/dist/code/editor-factory.d.ts

@@ -0,0 +1,41 @@
+import { Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+//#region src/code/editor-factory.d.ts
+export interface CodeEditorOptions {
+  /** The element the editor is mounted into immediately. */
+  parent: HTMLElement;
+  /** The initial document. Default: empty. */
+  doc?: string;
+  /** Default: false. */
+  readOnly?: boolean;
+  /** Soft-wrap long lines. Default: false. */
+  wordWrap?: boolean;
+  /** A language id (`languageOf(path)`, or any id given to `registerLanguage`); applied as soon as it resolves. */
+  language?: string;
+  /** Mod-S was pressed. */
+  onSaveShortcut?: () => void;
+  /** The document was edited (not: replaced through `setDocument`). Read it with `view.state.doc.toString()`. */
+  onChange?: (view: EditorView) => void;
+}
+/**
+ * Builds a CodeMirror `EditorView` mounted into `parent`. The view is the source of truth of the buffer
+ * (`view.state.doc.toString()`); the caller owns its lifecycle and calls `view.destroy()` when unmounting.
+ */
+export declare function createCodeEditor(options: CodeEditorOptions): EditorView;
+export declare function setReadOnly(view: EditorView, readOnly: boolean): void;
+export declare function setWordWrap(view: EditorView, wordWrap: boolean): void;
+/** Installs a resolved language pack (`null`: none, plain text). See `loadLanguage` to go from an id. */
+export declare function setLanguage(view: EditorView, support: Extension | null): void;
+/**
+ * Resolves the language `id` (`resolveLanguage`) and installs it; `undefined` or an unknown id clears the language.
+ * Safe to call repeatedly: only the latest request wins, and a view destroyed meanwhile is left alone. Resolves to
+ * whether the language was installed.
+ */
+export declare function loadLanguage(view: EditorView, id: string | undefined): Promise<boolean>;
+/**
+ * Replaces the whole document with the host's text: no `onChange`, outside the undo history (loading a file is not an
+ * edit), the selection clamped to the new text. Does nothing when the text is already the document.
+ */
+export declare function setDocument(view: EditorView, doc: string): void;
+//#endregion
+//# sourceMappingURL=editor-factory.d.ts.map

package/dist/code/editor-factory.js

@@ -0,0 +1,126 @@
+import { skaileChromeTheme } from "./chrome-theme.js";
+import { languageCompartment, readOnlyCompartment, wrapCompartment } from "./compartments.js";
+import { skaileSyntaxHighlighting } from "./highlight-style.js";
+import { resolveLanguage } from "./lang-registry.js";
+import { defaultKeymap, history, historyKeymap, indentWithTab } from "@codemirror/commands";
+import { bracketMatching, foldGutter, foldKeymap } from "@codemirror/language";
+import { search, searchKeymap } from "@codemirror/search";
+import { Annotation, EditorState, Transaction } from "@codemirror/state";
+import { EditorView, ViewPlugin, highlightActiveLine, highlightActiveLineGutter, keymap, lineNumbers } from "@codemirror/view";
+//#region src/code/editor-factory.ts
+/** Marks the transactions `setDocument` makes: the host's own text, not an edit. */
+const external = Annotation.define();
+/** Views that were destroyed, so a language that resolves late is not dispatched into them. */
+const destroyed = /* @__PURE__ */ new WeakSet();
+const lifecycle = ViewPlugin.define((view) => ({ destroy: () => destroyed.add(view) }));
+/** The language last requested per view: an earlier, slower request must not overwrite a later one. */
+const requested = /* @__PURE__ */ new WeakMap();
+/**
+* Both `EditorState.readOnly` and `EditorView.editable` are set, always together: they control different things (what
+* transactions are accepted, whether the content is focusable) and setting only one is a classic desync.
+*/
+function readOnlyExtensions(readOnly) {
+	return [EditorState.readOnly.of(readOnly), EditorView.editable.of(!readOnly)];
+}
+function wrapExtensions(wordWrap) {
+	return wordWrap ? [EditorView.lineWrapping] : [];
+}
+/**
+* Builds a CodeMirror `EditorView` mounted into `parent`. The view is the source of truth of the buffer
+* (`view.state.doc.toString()`); the caller owns its lifecycle and calls `view.destroy()` when unmounting.
+*/
+function createCodeEditor(options) {
+	const { parent, doc = "", readOnly = false, wordWrap = false, language, onSaveShortcut, onChange } = options;
+	const state = EditorState.create({
+		doc,
+		extensions: [
+			lineNumbers(),
+			foldGutter(),
+			highlightActiveLine(),
+			highlightActiveLineGutter(),
+			bracketMatching(),
+			history(),
+			search({ top: true }),
+			keymap.of([
+				...defaultKeymap,
+				...historyKeymap,
+				...searchKeymap,
+				...foldKeymap,
+				indentWithTab
+			]),
+			keymap.of([{
+				key: "Mod-s",
+				preventDefault: true,
+				run: () => {
+					onSaveShortcut?.();
+					return true;
+				}
+			}]),
+			skaileChromeTheme,
+			skaileSyntaxHighlighting,
+			lifecycle,
+			languageCompartment.of([]),
+			readOnlyCompartment.of(readOnlyExtensions(readOnly)),
+			wrapCompartment.of(wrapExtensions(wordWrap)),
+			EditorView.updateListener.of((update) => {
+				if (update.docChanged && !update.transactions.some((transaction) => transaction.annotation(external))) onChange?.(update.view);
+			})
+		]
+	});
+	const view = new EditorView({
+		state,
+		parent
+	});
+	view.dom.classList.toggle("cm-skaile-readonly", readOnly);
+	if (language) loadLanguage(view, language);
+	return view;
+}
+function setReadOnly(view, readOnly) {
+	view.dispatch({ effects: readOnlyCompartment.reconfigure(readOnlyExtensions(readOnly)) });
+	view.dom.classList.toggle("cm-skaile-readonly", readOnly);
+}
+function setWordWrap(view, wordWrap) {
+	view.dispatch({ effects: wrapCompartment.reconfigure(wrapExtensions(wordWrap)) });
+}
+/** Installs a resolved language pack (`null`: none, plain text). See `loadLanguage` to go from an id. */
+function setLanguage(view, support) {
+	view.dispatch({ effects: languageCompartment.reconfigure(support ?? []) });
+}
+/**
+* Resolves the language `id` (`resolveLanguage`) and installs it; `undefined` or an unknown id clears the language.
+* Safe to call repeatedly: only the latest request wins, and a view destroyed meanwhile is left alone. Resolves to
+* whether the language was installed.
+*/
+async function loadLanguage(view, id) {
+	requested.set(view, id);
+	const support = id ? await resolveLanguage(id) : null;
+	if (destroyed.has(view) || requested.get(view) !== id) return false;
+	setLanguage(view, support);
+	return support !== null;
+}
+/**
+* Replaces the whole document with the host's text: no `onChange`, outside the undo history (loading a file is not an
+* edit), the selection clamped to the new text. Does nothing when the text is already the document.
+*/
+function setDocument(view, doc) {
+	const current = view.state.doc;
+	if (current.toString() === doc) return;
+	const anchor = Math.min(view.state.selection.main.anchor, doc.length);
+	const head = Math.min(view.state.selection.main.head, doc.length);
+	view.dispatch({
+		changes: {
+			from: 0,
+			to: current.length,
+			insert: doc
+		},
+		selection: {
+			anchor,
+			head
+		},
+		annotations: [external.of(true), Transaction.addToHistory.of(false)]
+	});
+}
+//#endregion
+export { createCodeEditor, loadLanguage, setDocument, setLanguage, setReadOnly, setWordWrap };
+
+//# sourceMappingURL=editor-factory.js.map

package/dist/code/editor-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-factory.js","names":[],"sources":["../../src/code/editor-factory.ts"],"sourcesContent":["import { defaultKeymap, history, historyKeymap, indentWithTab } from '@codemirror/commands'\nimport { bracketMatching, foldGutter, foldKeymap } from '@codemirror/language'\nimport { search, searchKeymap } from '@codemirror/search'\nimport { Annotation, EditorState, type Extension, Transaction } from '@codemirror/state'\nimport { EditorView, highlightActiveLine, highlightActiveLineGutter, type KeyBinding, keymap, lineNumbers, ViewPlugin } from '@codemirror/view'\nimport { skaileChromeTheme } from './chrome-theme'\nimport { languageCompartment, readOnlyCompartment, wrapCompartment } from './compartments'\nimport { skaileSyntaxHighlighting } from './highlight-style'\nimport { resolveLanguage } from './lang-registry'\n\nexport interface CodeEditorOptions {\n  /** The element the editor is mounted into immediately. */\n  parent: HTMLElement\n  /** The initial document. Default: empty. */\n  doc?: string\n  /** Default: false. */\n  readOnly?: boolean\n  /** Soft-wrap long lines. Default: false. */\n  wordWrap?: boolean\n  /** A language id (`languageOf(path)`, or any id given to `registerLanguage`); applied as soon as it resolves. */\n  language?: string\n  /** Mod-S was pressed. */\n  onSaveShortcut?: () => void\n  /** The document was edited (not: replaced through `setDocument`). Read it with `view.state.doc.toString()`. */\n  onChange?: (view: EditorView) => void\n}\n\n/** Marks the transactions `setDocument` makes: the host's own text, not an edit. */\nconst external = Annotation.define<boolean>()\n\n/** Views that were destroyed, so a language that resolves late is not dispatched into them. */\nconst destroyed = new WeakSet<EditorView>()\nconst lifecycle = ViewPlugin.define(view => ({ destroy: () => destroyed.add(view) }))\n\n/** The language last requested per view: an earlier, slower request must not overwrite a later one. */\nconst requested = new WeakMap<EditorView, string | undefined>()\n\n/**\n * Both `EditorState.readOnly` and `EditorView.editable` are set, always together: they control different things (what\n * transactions are accepted, whether the content is focusable) and setting only one is a classic desync.\n */\nfunction readOnlyExtensions(readOnly: boolean): Extension[] {\n  return [EditorState.readOnly.of(readOnly), EditorView.editable.of(!readOnly)]\n}\n\nfunction wrapExtensions(wordWrap: boolean): Extension[] {\n  return wordWrap ? [EditorView.lineWrapping] : []\n}\n\n/**\n * Builds a CodeMirror `EditorView` mounted into `parent`. The view is the source of truth of the buffer\n * (`view.state.doc.toString()`); the caller owns its lifecycle and calls `view.destroy()` when unmounting.\n */\nexport function createCodeEditor(options: CodeEditorOptions): EditorView {\n  const { parent, doc = '', readOnly = false, wordWrap = false, language, onSaveShortcut, onChange } = options\n\n  const state = EditorState.create({\n    doc,\n    extensions: [\n      lineNumbers(),\n      foldGutter(),\n      highlightActiveLine(),\n      highlightActiveLineGutter(),\n      bracketMatching(),\n      history(),\n      search({ top: true }),\n      // `indentWithTab` follows the `indentUnit` facet (a language pack may set it, e.g. Python's four spaces). Esc\n      // releases Tab back to focus traversal. The cast: `@codemirror/*` sub-packages may resolve two copies of\n      // `@codemirror/view` in a host, whose `KeyBinding` types are structurally equal but nominally distinct.\n      keymap.of([...defaultKeymap, ...historyKeymap, ...searchKeymap, ...foldKeymap, indentWithTab] as KeyBinding[]),\n      keymap.of([{\n        key: 'Mod-s',\n        preventDefault: true,\n        run: () => {\n          onSaveShortcut?.()\n          return true\n        },\n      }]),\n      skaileChromeTheme,\n      skaileSyntaxHighlighting,\n      lifecycle,\n      languageCompartment.of([]),\n      readOnlyCompartment.of(readOnlyExtensions(readOnly)),\n      wrapCompartment.of(wrapExtensions(wordWrap)),\n      EditorView.updateListener.of((update) => {\n        if (update.docChanged && !update.transactions.some(transaction => transaction.annotation(external))) onChange?.(update.view)\n      }),\n    ],\n  })\n\n  const view = new EditorView({ state, parent })\n  view.dom.classList.toggle('cm-skaile-readonly', readOnly)\n  if (language) void loadLanguage(view, language)\n  return view\n}\n\nexport function setReadOnly(view: EditorView, readOnly: boolean): void {\n  view.dispatch({ effects: readOnlyCompartment.reconfigure(readOnlyExtensions(readOnly)) })\n  view.dom.classList.toggle('cm-skaile-readonly', readOnly)\n}\n\nexport function setWordWrap(view: EditorView, wordWrap: boolean): void {\n  view.dispatch({ effects: wrapCompartment.reconfigure(wrapExtensions(wordWrap)) })\n}\n\n/** Installs a resolved language pack (`null`: none, plain text). See `loadLanguage` to go from an id. */\nexport function setLanguage(view: EditorView, support: Extension | null): void {\n  view.dispatch({ effects: languageCompartment.reconfigure(support ?? []) })\n}\n\n/**\n * Resolves the language `id` (`resolveLanguage`) and installs it; `undefined` or an unknown id clears the language.\n * Safe to call repeatedly: only the latest request wins, and a view destroyed meanwhile is left alone. Resolves to\n * whether the language was installed.\n */\nexport async function loadLanguage(view: EditorView, id: string | undefined): Promise<boolean> {\n  requested.set(view, id)\n  const support = id ? await resolveLanguage(id) : null\n  if (destroyed.has(view) || requested.get(view) !== id) return false\n  setLanguage(view, support)\n  return support !== null\n}\n\n/**\n * Replaces the whole document with the host's text: no `onChange`, outside the undo history (loading a file is not an\n * edit), the selection clamped to the new text. Does nothing when the text is already the document.\n */\nexport function setDocument(view: EditorView, doc: string): void {\n  const current = view.state.doc\n  if (current.toString() === doc) return\n  const anchor = Math.min(view.state.selection.main.anchor, doc.length)\n  const head = Math.min(view.state.selection.main.head, doc.length)\n  view.dispatch({\n    changes: { from: 0, to: current.length, insert: doc },\n    selection: { anchor, head },\n    annotations: [external.of(true), Transaction.addToHistory.of(false)],\n  })\n}\n"],"mappings":"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"}

package/dist/code/format-json.d.ts

@@ -0,0 +1,27 @@
+import { EditorView } from "@codemirror/view";
+//#region src/code/format-json.d.ts
+export type FormatJsonResult = {
+  ok: true;
+  text: string;
+  changed: boolean;
+} | {
+  ok: false;
+  error: string;
+};
+/** Only strict `.json` — `.jsonc`/`.json5` allow comments that JSON.parse rejects, `.jsonl` is one value per line. */
+export declare function isJsonFormattablePath(path: string): boolean;
+/** Pretty-prints JSON with two-space indentation, keeping a trailing newline if the input had one. */
+export declare function formatJsonText(text: string): FormatJsonResult;
+/** A read-only editor is refused before parsing, so callers can tell it apart from invalid JSON. */
+export type FormatJsonInEditorResult = FormatJsonResult | {
+  ok: false;
+  readOnly: true;
+};
+/**
+ * Formats the editor's document in place as one transaction, so a single undo
+ * reverts it and the editor's change listener marks the buffer dirty. A
+ * read-only editor and an unparseable document are left untouched.
+ */
+export declare function formatJsonInEditor(view: EditorView): FormatJsonInEditorResult;
+//#endregion
+//# sourceMappingURL=format-json.d.ts.map

package/dist/code/format-json.js

@@ -0,0 +1,94 @@
+//#region src/code/format-json.ts
+/** Only strict `.json` — `.jsonc`/`.json5` allow comments that JSON.parse rejects, `.jsonl` is one value per line. */
+function isJsonFormattablePath(path) {
+	return path.toLowerCase().endsWith(".json");
+}
+const INDENT = "  ";
+function isWhitespace(ch) {
+	return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+/**
+* Re-indents already-validated JSON token by token instead of round-tripping
+* through `JSON.stringify(JSON.parse(...))`: a round trip would silently round
+* integers past 2^53, drop duplicate keys and rewrite escapes and number
+* spellings. The layout matches `JSON.stringify(value, null, 2)`.
+*/
+function reindent(text) {
+	let out = "";
+	let depth = 0;
+	let inString = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charAt(i);
+		if (inString) {
+			out += ch;
+			if (ch === "\\") out += text.charAt(++i);
+			else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (isWhitespace(ch)) continue;
+		if (ch === "{" || ch === "[") {
+			const close = ch === "{" ? "}" : "]";
+			let j = i + 1;
+			while (j < text.length && isWhitespace(text.charAt(j))) j++;
+			if (text[j] === close) {
+				out += ch + close;
+				i = j;
+				continue;
+			}
+			depth++;
+			out += `${ch}\n${INDENT.repeat(depth)}`;
+		} else if (ch === "}" || ch === "]") {
+			depth--;
+			out += `\n${INDENT.repeat(depth)}${ch}`;
+		} else if (ch === ",") out += `,\n${INDENT.repeat(depth)}`;
+		else if (ch === ":") out += ": ";
+		else {
+			if (ch === "\"") inString = true;
+			out += ch;
+		}
+	}
+	return out;
+}
+/** Pretty-prints JSON with two-space indentation, keeping a trailing newline if the input had one. */
+function formatJsonText(text) {
+	try {
+		JSON.parse(text);
+	} catch (err) {
+		return {
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+	const formatted = reindent(text) + (text.endsWith("\n") ? "\n" : "");
+	return {
+		ok: true,
+		text: formatted,
+		changed: formatted !== text
+	};
+}
+/**
+* Formats the editor's document in place as one transaction, so a single undo
+* reverts it and the editor's change listener marks the buffer dirty. A
+* read-only editor and an unparseable document are left untouched.
+*/
+function formatJsonInEditor(view) {
+	if (view.state.readOnly) return {
+		ok: false,
+		readOnly: true
+	};
+	const current = view.state.doc.toString();
+	const result = formatJsonText(current);
+	if (result.ok && result.changed) view.dispatch({
+		changes: {
+			from: 0,
+			to: current.length,
+			insert: result.text
+		},
+		userEvent: "input.format"
+	});
+	return result;
+}
+//#endregion
+export { formatJsonInEditor, formatJsonText, isJsonFormattablePath };
+
+//# sourceMappingURL=format-json.js.map

package/dist/code/format-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-json.js","names":[],"sources":["../../src/code/format-json.ts"],"sourcesContent":["import type { EditorView } from '@codemirror/view'\n\nexport type FormatJsonResult = { ok: true; text: string; changed: boolean } | { ok: false; error: string }\n\n/** Only strict `.json` — `.jsonc`/`.json5` allow comments that JSON.parse rejects, `.jsonl` is one value per line. */\nexport function isJsonFormattablePath(path: string): boolean {\n  return path.toLowerCase().endsWith('.json')\n}\n\nconst INDENT = '  '\n\nfunction isWhitespace(ch: string): boolean {\n  return ch === ' ' || ch === '\\t' || ch === '\\n' || ch === '\\r'\n}\n\n/**\n * Re-indents already-validated JSON token by token instead of round-tripping\n * through `JSON.stringify(JSON.parse(...))`: a round trip would silently round\n * integers past 2^53, drop duplicate keys and rewrite escapes and number\n * spellings. The layout matches `JSON.stringify(value, null, 2)`.\n */\nfunction reindent(text: string): string {\n  let out = ''\n  let depth = 0\n  let inString = false\n  for (let i = 0; i < text.length; i++) {\n    const ch = text.charAt(i)\n    if (inString) {\n      out += ch\n      if (ch === '\\\\') {\n        out += text.charAt(++i)\n      } else if (ch === '\"') {\n        inString = false\n      }\n      continue\n    }\n    if (isWhitespace(ch)) {\n      continue\n    }\n    if (ch === '{' || ch === '[') {\n      const close = ch === '{' ? '}' : ']'\n      let j = i + 1\n      while (j < text.length && isWhitespace(text.charAt(j))) {\n        j++\n      }\n      if (text[j] === close) {\n        out += ch + close\n        i = j\n        continue\n      }\n      depth++\n      out += `${ch}\\n${INDENT.repeat(depth)}`\n    } else if (ch === '}' || ch === ']') {\n      depth--\n      out += `\\n${INDENT.repeat(depth)}${ch}`\n    } else if (ch === ',') {\n      out += `,\\n${INDENT.repeat(depth)}`\n    } else if (ch === ':') {\n      out += ': '\n    } else {\n      if (ch === '\"') {\n        inString = true\n      }\n      out += ch\n    }\n  }\n  return out\n}\n\n/** Pretty-prints JSON with two-space indentation, keeping a trailing newline if the input had one. */\nexport function formatJsonText(text: string): FormatJsonResult {\n  try {\n    JSON.parse(text)\n  } catch (err) {\n    return { ok: false, error: err instanceof Error ? err.message : String(err) }\n  }\n  const formatted = reindent(text) + (text.endsWith('\\n') ? '\\n' : '')\n  return { ok: true, text: formatted, changed: formatted !== text }\n}\n\n/** A read-only editor is refused before parsing, so callers can tell it apart from invalid JSON. */\nexport type FormatJsonInEditorResult = FormatJsonResult | { ok: false; readOnly: true }\n\n/**\n * Formats the editor's document in place as one transaction, so a single undo\n * reverts it and the editor's change listener marks the buffer dirty. A\n * read-only editor and an unparseable document are left untouched.\n */\nexport function formatJsonInEditor(view: EditorView): FormatJsonInEditorResult {\n  if (view.state.readOnly) {\n    return { ok: false, readOnly: true }\n  }\n  const current = view.state.doc.toString()\n  const result = formatJsonText(current)\n  if (result.ok && result.changed) {\n    view.dispatch({\n      changes: { from: 0, to: current.length, insert: result.text },\n      userEvent: 'input.format',\n    })\n  }\n  return result\n}\n"],"mappings":";;AAKA,SAAgB,sBAAsB,MAAuB;CAC3D,OAAO,KAAK,YAAY,CAAC,CAAC,SAAS,OAAO;AAC5C;AAEA,MAAM,SAAS;AAEf,SAAS,aAAa,IAAqB;CACzC,OAAO,OAAO,OAAO,OAAO,OAAQ,OAAO,QAAQ,OAAO;AAC5D;;;;;;;AAQA,SAAS,SAAS,MAAsB;CACtC,IAAI,MAAM;CACV,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,KAAK,KAAK,OAAO,CAAC;EACxB,IAAI,UAAU;GACZ,OAAO;GACP,IAAI,OAAO,MACT,OAAO,KAAK,OAAO,EAAE,CAAC;QACjB,IAAI,OAAO,MAChB,WAAW;GAEb;EACF;EACA,IAAI,aAAa,EAAE,GACjB;EAEF,IAAI,OAAO,OAAO,OAAO,KAAK;GAC5B,MAAM,QAAQ,OAAO,MAAM,MAAM;GACjC,IAAI,IAAI,IAAI;GACZ,OAAO,IAAI,KAAK,UAAU,aAAa,KAAK,OAAO,CAAC,CAAC,GACnD;GAEF,IAAI,KAAK,OAAO,OAAO;IACrB,OAAO,KAAK;IACZ,IAAI;IACJ;GACF;GACA;GACA,OAAO,GAAG,GAAG,IAAI,OAAO,OAAO,KAAK;EACtC,OAAO,IAAI,OAAO,OAAO,OAAO,KAAK;GACnC;GACA,OAAO,KAAK,OAAO,OAAO,KAAK,IAAI;EACrC,OAAO,IAAI,OAAO,KAChB,OAAO,MAAM,OAAO,OAAO,KAAK;OAC3B,IAAI,OAAO,KAChB,OAAO;OACF;GACL,IAAI,OAAO,MACT,WAAW;GAEb,OAAO;EACT;CACF;CACA,OAAO;AACT;;AAGA,SAAgB,eAAe,MAAgC;CAC7D,IAAI;EACF,KAAK,MAAM,IAAI;CACjB,SAAS,KAAK;EACZ,OAAO;GAAE,IAAI;GAAO,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;EAAE;CAC9E;CACA,MAAM,YAAY,SAAS,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,OAAO;CACjE,OAAO;EAAE,IAAI;EAAM,MAAM;EAAW,SAAS,cAAc;CAAK;AAClE;;;;;;AAUA,SAAgB,mBAAmB,MAA4C;CAC7E,IAAI,KAAK,MAAM,UACb,OAAO;EAAE,IAAI;EAAO,UAAU;CAAK;CAErC,MAAM,UAAU,KAAK,MAAM,IAAI,SAAS;CACxC,MAAM,SAAS,eAAe,OAAO;CACrC,IAAI,OAAO,MAAM,OAAO,SACtB,KAAK,SAAS;EACZ,SAAS;GAAE,MAAM;GAAG,IAAI,QAAQ;GAAQ,QAAQ,OAAO;EAAK;EAC5D,WAAW;CACb,CAAC;CAEH,OAAO;AACT"}

package/dist/code/highlight-style.js

@@ -0,0 +1,118 @@
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { tags } from "@lezer/highlight";
+//#region src/code/highlight-style.ts
+const fg = "var(--sk-fg, #18181b)";
+const muted = "var(--sk-muted, #71717a)";
+const primary = "var(--sk-primary, #2563eb)";
+const success = "var(--sk-success, #16a34a)";
+const warning = "var(--sk-warning, #d97706)";
+const danger = "var(--sk-danger, #dc2626)";
+const mix = (color, base, percent) => `color-mix(in oklab, ${color} ${percent}%, ${base})`;
+/**
+* Maps Lezer tags to the shared `--sk-*` tokens, so light/dark switching is the host's token values and needs no
+* JavaScript. The palette is derived from the semantic tokens (primary, success, warning, danger, muted); what no rule
+* matches renders in the foreground colour.
+*/
+const skaileHighlightStyle = HighlightStyle.define([
+	{
+		tag: [
+			tags.comment,
+			tags.lineComment,
+			tags.blockComment,
+			tags.docComment
+		],
+		color: muted,
+		fontStyle: "italic"
+	},
+	{
+		tag: [
+			tags.keyword,
+			tags.controlKeyword,
+			tags.modifier,
+			tags.definitionKeyword,
+			tags.operatorKeyword
+		],
+		color: primary
+	},
+	{
+		tag: [tags.string, tags.docString],
+		color: success
+	},
+	{
+		tag: [
+			tags.number,
+			tags.bool,
+			tags.null
+		],
+		color: warning
+	},
+	{
+		tag: [tags.function(tags.variableName), tags.function(tags.propertyName)],
+		color: mix(primary, fg, 70)
+	},
+	{
+		tag: [
+			tags.typeName,
+			tags.className,
+			tags.namespace,
+			tags.standard(tags.typeName)
+		],
+		color: mix(warning, fg, 75)
+	},
+	{
+		tag: [tags.variableName, tags.special(tags.variableName)],
+		color: fg
+	},
+	{
+		tag: [tags.propertyName],
+		color: mix(primary, fg, 45)
+	},
+	{
+		tag: [tags.operator, tags.special(tags.operator)],
+		color: mix(fg, muted, 55)
+	},
+	{
+		tag: [
+			tags.punctuation,
+			tags.bracket,
+			tags.brace,
+			tags.paren,
+			tags.separator
+		],
+		color: muted
+	},
+	{
+		tag: [tags.tagName],
+		color: danger
+	},
+	{
+		tag: [tags.attributeName, tags.attributeValue],
+		color: warning
+	},
+	{
+		tag: [tags.regexp],
+		color: mix(danger, warning, 60)
+	},
+	{
+		tag: [tags.escape, tags.special(tags.string)],
+		color: mix(danger, success, 60)
+	},
+	{
+		tag: [
+			tags.meta,
+			tags.processingInstruction,
+			tags.annotation
+		],
+		color: mix(muted, primary, 70)
+	},
+	{
+		tag: [tags.invalid],
+		color: danger,
+		textDecoration: "underline wavy"
+	}
+]);
+const skaileSyntaxHighlighting = syntaxHighlighting(skaileHighlightStyle);
+//#endregion
+export { skaileHighlightStyle, skaileSyntaxHighlighting };
+
+//# sourceMappingURL=highlight-style.js.map

package/dist/code/highlight-style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight-style.js","names":["t"],"sources":["../../src/code/highlight-style.ts"],"sourcesContent":["import { HighlightStyle, syntaxHighlighting } from '@codemirror/language'\nimport { tags as t } from '@lezer/highlight'\n\nconst fg = 'var(--sk-fg, #18181b)'\nconst muted = 'var(--sk-muted, #71717a)'\nconst primary = 'var(--sk-primary, #2563eb)'\nconst success = 'var(--sk-success, #16a34a)'\nconst warning = 'var(--sk-warning, #d97706)'\nconst danger = 'var(--sk-danger, #dc2626)'\nconst mix = (color: string, base: string, percent: number) => `color-mix(in oklab, ${color} ${percent}%, ${base})`\n\n/**\n * Maps Lezer tags to the shared `--sk-*` tokens, so light/dark switching is the host's token values and needs no\n * JavaScript. The palette is derived from the semantic tokens (primary, success, warning, danger, muted); what no rule\n * matches renders in the foreground colour.\n */\nexport const skaileHighlightStyle = HighlightStyle.define([\n  { tag: [t.comment, t.lineComment, t.blockComment, t.docComment], color: muted, fontStyle: 'italic' },\n  { tag: [t.keyword, t.controlKeyword, t.modifier, t.definitionKeyword, t.operatorKeyword], color: primary },\n  { tag: [t.string, t.docString], color: success },\n  { tag: [t.number, t.bool, t.null], color: warning },\n  { tag: [t.function(t.variableName), t.function(t.propertyName)], color: mix(primary, fg, 70) },\n  { tag: [t.typeName, t.className, t.namespace, t.standard(t.typeName)], color: mix(warning, fg, 75) },\n  { tag: [t.variableName, t.special(t.variableName)], color: fg },\n  { tag: [t.propertyName], color: mix(primary, fg, 45) },\n  { tag: [t.operator, t.special(t.operator)], color: mix(fg, muted, 55) },\n  { tag: [t.punctuation, t.bracket, t.brace, t.paren, t.separator], color: muted },\n  { tag: [t.tagName], color: danger },\n  { tag: [t.attributeName, t.attributeValue], color: warning },\n  { tag: [t.regexp], color: mix(danger, warning, 60) },\n  // `t.special(t.string)` is listed only here, so escapes (\\n, \\\") stand out from the string body.\n  { tag: [t.escape, t.special(t.string)], color: mix(danger, success, 60) },\n  { tag: [t.meta, t.processingInstruction, t.annotation], color: mix(muted, primary, 70) },\n  { tag: [t.invalid], color: danger, textDecoration: 'underline wavy' },\n])\n\nexport const skaileSyntaxHighlighting = syntaxHighlighting(skaileHighlightStyle)\n"],"mappings":";;;AAGA,MAAM,KAAK;AACX,MAAM,QAAQ;AACd,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,SAAS;AACf,MAAM,OAAO,OAAe,MAAc,YAAoB,uBAAuB,MAAM,GAAG,QAAQ,KAAK,KAAK;;;;;;AAOhH,MAAa,uBAAuB,eAAe,OAAO;CACxD;EAAE,KAAK;GAACA,KAAE;GAASA,KAAE;GAAaA,KAAE;GAAcA,KAAE;EAAU;EAAG,OAAO;EAAO,WAAW;CAAS;CACnG;EAAE,KAAK;GAACA,KAAE;GAASA,KAAE;GAAgBA,KAAE;GAAUA,KAAE;GAAmBA,KAAE;EAAe;EAAG,OAAO;CAAQ;CACzG;EAAE,KAAK,CAACA,KAAE,QAAQA,KAAE,SAAS;EAAG,OAAO;CAAQ;CAC/C;EAAE,KAAK;GAACA,KAAE;GAAQA,KAAE;GAAMA,KAAE;EAAI;EAAG,OAAO;CAAQ;CAClD;EAAE,KAAK,CAACA,KAAE,SAASA,KAAE,YAAY,GAAGA,KAAE,SAASA,KAAE,YAAY,CAAC;EAAG,OAAO,IAAI,SAAS,IAAI,EAAE;CAAE;CAC7F;EAAE,KAAK;GAACA,KAAE;GAAUA,KAAE;GAAWA,KAAE;GAAWA,KAAE,SAASA,KAAE,QAAQ;EAAC;EAAG,OAAO,IAAI,SAAS,IAAI,EAAE;CAAE;CACnG;EAAE,KAAK,CAACA,KAAE,cAAcA,KAAE,QAAQA,KAAE,YAAY,CAAC;EAAG,OAAO;CAAG;CAC9D;EAAE,KAAK,CAACA,KAAE,YAAY;EAAG,OAAO,IAAI,SAAS,IAAI,EAAE;CAAE;CACrD;EAAE,KAAK,CAACA,KAAE,UAAUA,KAAE,QAAQA,KAAE,QAAQ,CAAC;EAAG,OAAO,IAAI,IAAI,OAAO,EAAE;CAAE;CACtE;EAAE,KAAK;GAACA,KAAE;GAAaA,KAAE;GAASA,KAAE;GAAOA,KAAE;GAAOA,KAAE;EAAS;EAAG,OAAO;CAAM;CAC/E;EAAE,KAAK,CAACA,KAAE,OAAO;EAAG,OAAO;CAAO;CAClC;EAAE,KAAK,CAACA,KAAE,eAAeA,KAAE,cAAc;EAAG,OAAO;CAAQ;CAC3D;EAAE,KAAK,CAACA,KAAE,MAAM;EAAG,OAAO,IAAI,QAAQ,SAAS,EAAE;CAAE;CAEnD;EAAE,KAAK,CAACA,KAAE,QAAQA,KAAE,QAAQA,KAAE,MAAM,CAAC;EAAG,OAAO,IAAI,QAAQ,SAAS,EAAE;CAAE;CACxE;EAAE,KAAK;GAACA,KAAE;GAAMA,KAAE;GAAuBA,KAAE;EAAU;EAAG,OAAO,IAAI,OAAO,SAAS,EAAE;CAAE;CACvF;EAAE,KAAK,CAACA,KAAE,OAAO;EAAG,OAAO;EAAQ,gBAAgB;CAAiB;AACtE,CAAC;AAED,MAAa,2BAA2B,mBAAmB,oBAAoB"}

package/dist/code/index.d.ts

@@ -0,0 +1,6 @@
+import { CodeEditorOptions, createCodeEditor, loadLanguage, setDocument, setLanguage, setReadOnly, setWordWrap } from "./editor-factory.js";
+import { FormatJsonInEditorResult, FormatJsonResult, formatJsonInEditor, formatJsonText, isJsonFormattablePath } from "./format-json.js";
+import { jsonl, jsonlLanguage } from "./jsonl-language.js";
+import { DocumentKind, kindOf, languageOf } from "./kind.js";
+import { LanguageLoader, RegisterLanguageOptions, isCoreLang, registerLanguage, resolveLanguage } from "./lang-registry.js";
+export { type CodeEditorOptions, type DocumentKind, type FormatJsonInEditorResult, type FormatJsonResult, type LanguageLoader, type RegisterLanguageOptions, createCodeEditor, formatJsonInEditor, formatJsonText, isCoreLang, isJsonFormattablePath, jsonl, jsonlLanguage, kindOf, languageOf, loadLanguage, registerLanguage, resolveLanguage, setDocument, setLanguage, setReadOnly, setWordWrap };

package/dist/code/index.js

@@ -0,0 +1,6 @@
+import { jsonl, jsonlLanguage } from "./jsonl-language.js";
+import { isCoreLang, registerLanguage, resolveLanguage } from "./lang-registry.js";
+import { createCodeEditor, loadLanguage, setDocument, setLanguage, setReadOnly, setWordWrap } from "./editor-factory.js";
+import { formatJsonInEditor, formatJsonText, isJsonFormattablePath } from "./format-json.js";
+import { kindOf, languageOf } from "./kind.js";
+export { createCodeEditor, formatJsonInEditor, formatJsonText, isCoreLang, isJsonFormattablePath, jsonl, jsonlLanguage, kindOf, languageOf, loadLanguage, registerLanguage, resolveLanguage, setDocument, setLanguage, setReadOnly, setWordWrap };

package/dist/code/jsonl-language.d.ts

@@ -0,0 +1,6 @@
+import { LanguageSupport, StreamLanguage } from "@codemirror/language";
+//#region src/code/jsonl-language.d.ts
+export declare const jsonlLanguage: StreamLanguage<object>;
+export declare function jsonl(): LanguageSupport;
+//#endregion
+//# sourceMappingURL=jsonl-language.d.ts.map

package/dist/code/jsonl-language.js

@@ -0,0 +1,33 @@
+import { LanguageSupport, StreamLanguage } from "@codemirror/language";
+const jsonlLanguage = StreamLanguage.define({
+	name: "jsonl",
+	startState: () => ({}),
+	token(stream) {
+		if (stream.eatSpace()) return null;
+		if (stream.peek() === "\"") {
+			stream.next();
+			let escaped = false;
+			for (let ch = stream.next(); ch; ch = stream.next()) {
+				if (ch === "\"" && !escaped) break;
+				escaped = !escaped && ch === "\\";
+			}
+			return stream.match(/^\s*:/, false) ? "propertyName" : "string";
+		}
+		if (stream.match(/^-?\d+(\.\d+)?([eE][+-]?\d+)?/)) return "number";
+		if (stream.match(/^(true|false)\b/)) return "bool";
+		if (stream.match(/^null\b/)) return "null";
+		const ch = stream.next();
+		if (ch === "{" || ch === "}") return "brace";
+		if (ch === "[" || ch === "]") return "squareBracket";
+		if (ch === "," || ch === ":") return "punctuation";
+		stream.match(/^[^\s"{}[\],:]*/);
+		return "invalid";
+	}
+});
+function jsonl() {
+	return new LanguageSupport(jsonlLanguage);
+}
+//#endregion
+export { jsonl, jsonlLanguage };
+
+//# sourceMappingURL=jsonl-language.js.map

package/dist/code/jsonl-language.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-language.js","names":[],"sources":["../../src/code/jsonl-language.ts"],"sourcesContent":["import { LanguageSupport, StreamLanguage, type StreamParser } from '@codemirror/language'\n\n/**\n * JSON Lines / NDJSON: one JSON value per line.\n *\n * Deliberately a stateless per-line tokenizer rather than the Lezer JSON\n * grammar. That grammar parses one document, so a single malformed record (a\n * truncated log line) swallows every line after it into its error recovery —\n * misreading later strings as keys. Here nothing carries across a newline, so\n * each record highlights on its own.\n */\nconst jsonlParser: StreamParser<object> = {\n  name: 'jsonl',\n  startState: () => ({}),\n  token(stream) {\n    if (stream.eatSpace()) {\n      return null\n    }\n    if (stream.peek() === '\"') {\n      stream.next()\n      let escaped = false\n      for (let ch = stream.next(); ch; ch = stream.next()) {\n        if (ch === '\"' && !escaped) {\n          break\n        }\n        escaped = !escaped && ch === '\\\\'\n      }\n      // A string followed by `:` is an object key.\n      return stream.match(/^\\s*:/, false) ? 'propertyName' : 'string'\n    }\n    if (stream.match(/^-?\\d+(\\.\\d+)?([eE][+-]?\\d+)?/)) {\n      return 'number'\n    }\n    if (stream.match(/^(true|false)\\b/)) {\n      return 'bool'\n    }\n    if (stream.match(/^null\\b/)) {\n      return 'null'\n    }\n    const ch = stream.next()\n    if (ch === '{' || ch === '}') {\n      return 'brace'\n    }\n    if (ch === '[' || ch === ']') {\n      return 'squareBracket'\n    }\n    if (ch === ',' || ch === ':') {\n      return 'punctuation'\n    }\n    // Consume the whole run so a non-JSON line costs one node per word, not per character.\n    stream.match(/^[^\\s\"{}[\\],:]*/)\n    return 'invalid'\n  },\n}\n\nexport const jsonlLanguage = StreamLanguage.define(jsonlParser)\n\nexport function jsonl(): LanguageSupport {\n  return new LanguageSupport(jsonlLanguage)\n}\n"],"mappings":";AAuDA,MAAa,gBAAgB,eAAe,OAAO;CA3CjD,MAAM;CACN,mBAAmB,CAAC;CACpB,MAAM,QAAQ;EACZ,IAAI,OAAO,SAAS,GAClB,OAAO;EAET,IAAI,OAAO,KAAK,MAAM,MAAK;GACzB,OAAO,KAAK;GACZ,IAAI,UAAU;GACd,KAAK,IAAI,KAAK,OAAO,KAAK,GAAG,IAAI,KAAK,OAAO,KAAK,GAAG;IACnD,IAAI,OAAO,QAAO,CAAC,SACjB;IAEF,UAAU,CAAC,WAAW,OAAO;GAC/B;GAEA,OAAO,OAAO,MAAM,SAAS,KAAK,IAAI,iBAAiB;EACzD;EACA,IAAI,OAAO,MAAM,+BAA+B,GAC9C,OAAO;EAET,IAAI,OAAO,MAAM,iBAAiB,GAChC,OAAO;EAET,IAAI,OAAO,MAAM,SAAS,GACxB,OAAO;EAET,MAAM,KAAK,OAAO,KAAK;EACvB,IAAI,OAAO,OAAO,OAAO,KACvB,OAAO;EAET,IAAI,OAAO,OAAO,OAAO,KACvB,OAAO;EAET,IAAI,OAAO,OAAO,OAAO,KACvB,OAAO;EAGT,OAAO,MAAM,iBAAiB;EAC9B,OAAO;CACT;AAGiD,CAAW;AAE9D,SAAgB,QAAyB;CACvC,OAAO,IAAI,gBAAgB,aAAa;AAC1C"}

package/dist/code/kind.d.ts

@@ -0,0 +1,15 @@
+//#region src/code/kind.d.ts
+/** What a document is edited with: the rich Markdown surface, the code surface, or nothing this package renders. */
+export type DocumentKind = 'markdown' | 'code' | 'binary';
+/**
+ * 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.
+ */
+export declare function kindOf(path: string, mime?: string): DocumentKind;
+/** The language id `registerLanguage` knows `path`'s extension by, or `undefined` for plain text. */
+export declare function languageOf(path: string): string | undefined;
+//#endregion
+//# sourceMappingURL=kind.d.ts.map