@coldsmirk/inkstone-sql 0.34.2 → 0.36.0

package/README.md

@@ -41,7 +41,18 @@ Everything the intelligence answers goes through one lexical reader taken under
 
 ## The mirror invariant
 
-`noise.ts` (which runs of a statement are strings / comments / quoted names, per kind) and the marker grammar mirror [**polyglot's engine scanner**](https://github.com/coldsmirk/polyglot) (`sql/Placeholders`, over its profiles in `kinds/Dialect`) flag for flag, each kind under the two lexicons the sidecar reads it by: the database's own says where a statement ends and what is prose, and the one the kind's driver finds a `?` by says where the markers are — SQL Server nests a block comment, but Microsoft's driver ends one at its first close and binds a `?` past it; ClickHouse's driver reads a `?` as the conditional operator `a ? b : c` where a lone `:` follows it before any other `?`, and binds nothing through that `:` (`conditional.ts`). The scanner decides what actually binds; a reader that diverged would prompt for a parameter the engine refuses, or send a statement short of one it binds. **A scanner change requires a matching release of this package**, and the per-kind cases in `reader.test.ts` are the invariant's guard.
+`noise.ts` (which runs of a statement are strings / comments / quoted names, per kind) and the marker grammar mirror [**polyglot's engine scanner**](https://github.com/coldsmirk/polyglot) (`sql/Placeholders`, over its profiles in `kinds/Dialect`) flag for flag, each kind under the two lexicons the sidecar reads it by: the database's own says where a statement ends and what is prose, and the one the kind's driver finds a `?` by says where the markers are — SQL Server nests a block comment, but Microsoft's driver ends one at its first close and binds a `?` past it; ClickHouse's driver reads a `?` as the conditional operator `a ? b : c` where a lone `:` follows it before any other `?`, and binds nothing through that `:` (`conditional.ts`). The scanner decides what actually binds; a reader that diverged would prompt for a parameter the engine refuses, or send a statement short of one it binds. **A scanner change requires a matching release of this package**, and the per-kind cases in `reader.test.ts` are the invariant's guard. A statement that defines, changes or drops an object, or grants on one (its first word `CREATE`, `ALTER`, `DROP`, `COMMENT`, `RENAME`, `TRUNCATE`, `GRANT` or `REVOKE`), asks for no values: the scanner sends one as written, so a trigger's `:new` is the trigger's row and never a marker (`Placeholders.definesObjects`).
+
+## Where a statement ends
+
+`runnableStatement` parts a script as the kind's own command-line client parts it (`separators.ts`), since that is the tool a pasted script was written for:
+
+- **Oracle and 达梦** (SQL*Plus, DIsql): a line holding only `/` ends whatever stands above it; an anonymous block (`DECLARE` / `BEGIN`) or a stored PL/SQL unit (`CREATE [OR REPLACE] PROCEDURE | FUNCTION | PACKAGE | TRIGGER | TYPE | LIBRARY`, 达梦's `CLASS`) runs past its inner `;`s to the `;` after the `END` that closes it, read by its blocks' nesting, and keeps that `;`, which PL/SQL requires.
+- **MySQL** (`mysql`): `DELIMITER` lines name what ends a statement until the next, and a routine (`CREATE … PROCEDURE | FUNCTION | TRIGGER | EVENT`) runs past the `;`s of its compound statements.
+- **SQL Server** (sqlcmd): a line holding only `GO` ends a batch, and a `PROCEDURE`, `FUNCTION` or `TRIGGER` created or altered runs to its batch's end, as T-SQL reads a routine's body.
+- **PostgreSQL and Kingbase** (psql): a `CREATE [OR REPLACE] FUNCTION | PROCEDURE` runs past the `;`s of a `BEGIN ATOMIC … END` body, counted as psql counts them.
+
+Everything else ends at its `;`, which is left off. Completion, hover and signature help read the statement of a routine's body the caret is in; `separators.test.ts` is the guard.
 
 ## Structured refusals
 

package/dist/{assist-Cr2idunB.d.ts → assist-lygAVE0T.d.ts}

@@ -169,7 +169,9 @@ declare function readStatement(text: string, cursor: number, kind: SqlKind): Sta
 type Runnable = {
   kind: "one";
   /**
-   * The statement itself, without the whitespace around it or the `;` that ended it.
+   * The statement itself, without the whitespace around it or the separator that ended it:
+   * its `;`, a `/` or `GO` line, a `DELIMITER`'s own. A PL/SQL unit keeps its closing `;`,
+   * which is PL/SQL's own syntax (`separators.ts`).
    */
   text: string;
   /**

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as CatalogTable, S as CatalogFunction, _ as readCall, a as createSqlAssist, b as runnableStatement, c as SqlSource, d as CallRead, f as IdentifierRead, g as TableRef, h as StatementRead, i as SqlSignatureHelp, l as createSqlSchema, m as StatementContext, n as SqlCompletionCandidate, o as SqlCatalog, p as Runnable, r as SqlHoverCard, s as SqlSchema, t as SqlAssist, u as qualifiedName, v as readIdentifier, w as SqlKind, x as CatalogColumn, y as readStatement } from "./assist-Cr2idunB.js";
+import { C as CatalogTable, S as CatalogFunction, _ as readCall, a as createSqlAssist, b as runnableStatement, c as SqlSource, d as CallRead, f as IdentifierRead, g as TableRef, h as StatementRead, i as SqlSignatureHelp, l as createSqlSchema, m as StatementContext, n as SqlCompletionCandidate, o as SqlCatalog, p as Runnable, r as SqlHoverCard, s as SqlSchema, t as SqlAssist, u as qualifiedName, v as readIdentifier, w as SqlKind, x as CatalogColumn, y as readStatement } from "./assist-lygAVE0T.js";
 //#region src/functions.d.ts
 /**
  * The function vocabulary this bench speaks: the curated floor this project wrote

package/dist/index.js

@@ -431,18 +431,18 @@ const SPELLINGS = {
 		reserved: CLICKHOUSE_RESERVED
 	}
 };
-function delimited(spelling, name) {
+function delimited$1(spelling, name) {
 	const escaped = spelling.backslash === true ? name.replaceAll("\\", () => "\\\\") : name;
 	return `${spelling.open}${escaped.replaceAll(spelling.close, () => spelling.close + spelling.close)}${spelling.close}`;
 }
 function spellIdentifier(kind, name) {
 	const spelling = SPELLINGS[kind];
 	if (spelling.regular.test(name) && !spelling.reserved.has(name.toLowerCase())) return name;
-	return delimited(spelling, name);
+	return delimited$1(spelling, name);
 }
 function spellCallable(kind, name) {
 	const spelling = SPELLINGS[kind];
-	return spelling.regular.test(name) ? name : delimited(spelling, name);
+	return spelling.regular.test(name) ? name : delimited$1(spelling, name);
 }
 function spellQualifier(kind, source) {
 	return source.aliasWritten === "" ? spellIdentifier(kind, source.table.name) : source.aliasWritten;
@@ -801,17 +801,354 @@ function insideNoise(spans, cursor) {
 	return spans.some((span) => !span.name && cursor > span.start && (span.sealed ? cursor < span.end : cursor <= span.end));
 }
 //#endregion
+//#region src/separators.ts
+const TOKEN = /(?<word>[a-z_\u{0080}-\u{FFFF}][\w$#\u{0080}-\u{FFFF}]*)|\d[\w.]*|\S/giu;
+const SLASH_LINE = /^\s*\/\s*$/;
+const GO_LINE = /^\s*go(?:\s+\d+)?\s*$/i;
+const DELIMITER_LINE = /^\s*delimiter\s+(?<delimiter>\S+)\s*$/i;
+const PLSQL_MODIFIERS = /* @__PURE__ */ new Set([
+	"OR",
+	"REPLACE",
+	"EDITIONABLE",
+	"NONEDITIONABLE"
+]);
+const DECLARES = /* @__PURE__ */ new Set([
+	";",
+	"IS",
+	"AS",
+	"DECLARE",
+	"CREATE",
+	"REPLACE",
+	"EDITIONABLE",
+	"NONEDITIONABLE",
+	"MEMBER",
+	"STATIC",
+	"CONSTRUCTOR",
+	"MAP",
+	"ORDER",
+	"FINAL",
+	"INSTANTIABLE",
+	"OVERRIDING"
+]);
+const HEADS = /* @__PURE__ */ new Set([
+	"CREATE",
+	"REPLACE",
+	"EDITIONABLE",
+	"NONEDITIONABLE"
+]);
+const CALL_SPECS = /* @__PURE__ */ new Set([
+	"LANGUAGE",
+	"EXTERNAL",
+	"MLE"
+]);
+const MYSQL_ROUTINES = /* @__PURE__ */ new Set([
+	"PROCEDURE",
+	"FUNCTION",
+	"TRIGGER",
+	"EVENT"
+]);
+const MYSQL_STATEMENT_STARTS = /* @__PURE__ */ new Set([
+	";",
+	"BEGIN",
+	"THEN",
+	"ELSE",
+	"DO",
+	"LOOP",
+	"REPEAT",
+	":",
+	"ROW"
+]);
+const TSQL_ROUTINES = /* @__PURE__ */ new Set([
+	"PROCEDURE",
+	"PROC",
+	"FUNCTION",
+	"TRIGGER"
+]);
+function plsqlUnit(units) {
+	return ([first, ...rest]) => {
+		if (first === "DECLARE" || first === "BEGIN") return "plsql";
+		if (first !== "CREATE") return "plain";
+		const made = rest.find((word) => !PLSQL_MODIFIERS.has(word));
+		return made === void 0 ? null : units.has(made) ? "plsql" : "plain";
+	};
+}
+const MYSQL_DEFINERS = /* @__PURE__ */ new Set([
+	"DEFINER",
+	"AGGREGATE",
+	"=",
+	"@",
+	"(",
+	")"
+]);
+function mysqlUnit([first, ...rest]) {
+	if (first !== "CREATE") return "plain";
+	for (const [at, token] of rest.entries()) {
+		if (MYSQL_ROUTINES.has(token)) return "compound";
+		const before = at === 0 ? first : rest[at - 1];
+		if (!(MYSQL_DEFINERS.has(token) || before === "=" || before === "@")) return "plain";
+	}
+	return null;
+}
+function tsqlUnit([first, ...rest]) {
+	if (first !== "CREATE" && first !== "ALTER") return "plain";
+	const made = rest.find((word) => word !== "OR" && word !== "ALTER");
+	return made === void 0 ? null : TSQL_ROUTINES.has(made) ? "batch" : "plain";
+}
+function psqlUnit([first, ...rest]) {
+	if (first !== "CREATE") return "plain";
+	if (rest[0] === "OR" && rest.length < 3) return null;
+	const made = rest[0] === "OR" ? rest[1] === "REPLACE" ? rest[2] : "" : rest[0];
+	return made === void 0 ? null : made === "FUNCTION" || made === "PROCEDURE" ? "atomic" : "plain";
+}
+const UNIT_OF = {
+	oracle: plsqlUnit(/* @__PURE__ */ new Set([
+		"PROCEDURE",
+		"FUNCTION",
+		"PACKAGE",
+		"TRIGGER",
+		"TYPE",
+		"LIBRARY"
+	])),
+	dm: plsqlUnit(/* @__PURE__ */ new Set([
+		"PROCEDURE",
+		"FUNCTION",
+		"PACKAGE",
+		"TRIGGER",
+		"TYPE",
+		"CLASS"
+	])),
+	mysql: mysqlUnit,
+	sqlserver: tsqlUnit,
+	postgres: psqlUnit,
+	kingbase: psqlUnit,
+	doris: () => "plain",
+	clickhouse: () => "plain"
+};
+function parenthesized(reading, token) {
+	if (token === "(") reading.parens += 1;
+	else if (token === ")") reading.parens = Math.max(0, reading.parens - 1);
+	return token === "(" || token === ")" || reading.parens > 0;
+}
+function closes(reading, token, closers) {
+	const { closing } = reading;
+	reading.closing = false;
+	return closing && closers.has(token);
+}
+const PLSQL_CLOSERS = /* @__PURE__ */ new Set([
+	"IF",
+	"LOOP",
+	"CASE"
+]);
+function declares(reading) {
+	reading.header ||= DECLARES.has(reading.previous);
+}
+function heads(reading) {
+	reading.header ||= HEADS.has(reading.previous);
+}
+function opens(reading) {
+	if (!reading.header) return;
+	reading.header = false;
+	reading.opened = true;
+	reading.frames.push("declare");
+}
+function times(reading) {
+	reading.header ||= reading.frames.at(-1) === "compound";
+}
+function controls({ frames }) {
+	frames.push("control");
+}
+const PLSQL_WORDS = /* @__PURE__ */ new Map([
+	["DECLARE", ({ frames }) => {
+		frames.push("declare");
+	}],
+	["BEGIN", ({ frames }) => {
+		if (frames.at(-1) === "declare") frames[frames.length - 1] = "body";
+		else frames.push("body");
+	}],
+	["IF", controls],
+	["LOOP", controls],
+	["CASE", controls],
+	["END", (reading) => {
+		reading.frames.pop();
+		reading.closing = true;
+	}],
+	["IS", opens],
+	["AS", opens],
+	["PROCEDURE", declares],
+	["FUNCTION", declares],
+	["PACKAGE", heads],
+	["CLASS", heads],
+	["BODY", (reading) => {
+		reading.header ||= reading.previous === "TYPE";
+	}],
+	["TRIGGER", (reading) => {
+		if (reading.previous === "COMPOUND") reading.frames.push("compound");
+	}],
+	["BEFORE", times],
+	["AFTER", times],
+	["INSTEAD", times]
+]);
+function plsql(reading, token) {
+	if (parenthesized(reading, token)) return false;
+	if (token === ";") {
+		reading.header = false;
+		reading.closing = false;
+		return reading.frames.length === 0;
+	}
+	if (reading.opened) {
+		reading.opened = false;
+		if (CALL_SPECS.has(token)) reading.frames.pop();
+	}
+	if (!closes(reading, token, PLSQL_CLOSERS)) PLSQL_WORDS.get(token)?.(reading);
+	return false;
+}
+const MYSQL_CLOSERS = /* @__PURE__ */ new Set([
+	"IF",
+	"CASE",
+	"LOOP",
+	"WHILE",
+	"REPEAT"
+]);
+function compound(reading, token) {
+	if (parenthesized(reading, token)) return false;
+	if (token === ";") {
+		reading.closing = false;
+		return reading.frames.length === 0;
+	}
+	if (closes(reading, token, MYSQL_CLOSERS)) return false;
+	if (token === "BEGIN" || token === "CASE" || token === "LOOP") reading.frames.push("body");
+	else if ((token === "IF" || token === "WHILE" || token === "REPEAT") && MYSQL_STATEMENT_STARTS.has(reading.previous)) reading.frames.push("control");
+	else if (token === "END") {
+		reading.frames.pop();
+		reading.closing = true;
+	}
+	return false;
+}
+function atomic(reading, token) {
+	if (parenthesized(reading, token)) return false;
+	if (token === "BEGIN" || token === "CASE" && reading.depth >= 1) reading.depth += 1;
+	else if (token === "END" && reading.depth > 0) reading.depth -= 1;
+	return token === ";" && reading.depth === 0;
+}
+const ENDS = {
+	plain: (_, token) => token === ";",
+	plsql,
+	compound,
+	atomic,
+	batch: () => false
+};
+function reading() {
+	return {
+		head: [],
+		unit: null,
+		frames: [],
+		parens: 0,
+		previous: "",
+		closing: false,
+		header: false,
+		opened: false,
+		depth: 0
+	};
+}
+function token(script, value, at) {
+	if (script.current === null && value === ";") {
+		script.separators.push({
+			from: at,
+			to: at + 1
+		});
+		return;
+	}
+	const current = script.current ?? reading();
+	script.current = current;
+	if (current.unit === null && value !== ";") {
+		current.head.push(value);
+		current.unit = UNIT_OF[script.kind](current.head);
+	}
+	const unit = current.unit ?? "plain";
+	const ends = ENDS[unit](current, value);
+	current.previous = value;
+	if (ends) {
+		script.separators.push(unit === "plsql" ? {
+			from: at + 1,
+			to: at + 1
+		} : {
+			from: at,
+			to: at + 1
+		});
+		script.current = null;
+	}
+}
+function delimited(script, line, lineStart) {
+	const { delimiter } = script;
+	let after = 0;
+	for (let at = line.indexOf(delimiter); at !== -1; at = line.indexOf(delimiter, after)) {
+		script.separators.push({
+			from: lineStart + at,
+			to: lineStart + at + delimiter.length
+		});
+		script.current = null;
+		after = at + delimiter.length;
+	}
+	if (line.slice(after).trim() !== "") script.current ??= reading();
+}
+function statementSeparators(text, blanked, kind) {
+	const script = {
+		kind,
+		separators: [],
+		current: null,
+		delimiter: ";"
+	};
+	const lineEnds = kind === "oracle" || kind === "dm" ? SLASH_LINE : kind === "sqlserver" ? GO_LINE : null;
+	for (let lineStart = 0; lineStart <= blanked.length;) {
+		const newline = blanked.indexOf("\n", lineStart);
+		const lineEnd = newline === -1 ? blanked.length : newline;
+		const line = blanked.slice(lineStart, lineEnd);
+		const directive = kind === "mysql" && script.current === null && DELIMITER_LINE.test(line);
+		if (lineEnds?.test(line) === true) {
+			script.separators.push({
+				from: lineStart,
+				to: lineEnd
+			});
+			script.current = null;
+		} else if (directive) {
+			script.delimiter = DELIMITER_LINE.exec(text.slice(lineStart, lineEnd))?.groups?.delimiter ?? ";";
+			script.separators.push({
+				from: lineStart,
+				to: lineEnd
+			});
+		} else if (script.delimiter === ";") for (const match of line.matchAll(TOKEN)) token(script, (match.groups.word ?? match[0]).toUpperCase(), lineStart + match.index);
+		else delimited(script, line, lineStart);
+		lineStart = lineEnd + 1;
+	}
+	return script.separators;
+}
+//#endregion
 //#region src/reader.ts
 const TOKENS = /[\w$\u{0080}-\u{FFFF}]+|"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[(?:[^\]]|\]\])*\]|\S/gu;
 const TOKENS_TSQL = /[\w$#\u{0080}-\u{FFFF}]+|"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[(?:[^\]]|\]\])*\]|\S/gu;
 const WORD_KIND = /^[\w$"`[\u{0080}-\u{FFFF}]/u;
 const WORD_KIND_TSQL = /^[\w$#"`[\u{0080}-\u{FFFF}]/u;
-function statementBounds(blanked, cursor) {
-	const start = cursor === 0 ? 0 : blanked.lastIndexOf(";", cursor - 1) + 1;
-	const close = blanked.indexOf(";", cursor);
+function unitBounds(separators, cursor, length) {
+	let start = 0;
+	for (const separator of separators) {
+		if (separator.to > cursor) return {
+			start,
+			end: separator.from
+		};
+		start = separator.to;
+	}
 	return {
 		start,
-		end: close === -1 ? blanked.length : close
+		end: length
+	};
+}
+function statementBounds(blanked, separators, cursor) {
+	const unit = unitBounds(separators, cursor, blanked.length);
+	const before = cursor === 0 ? -1 : blanked.lastIndexOf(";", cursor - 1);
+	const close = blanked.indexOf(";", cursor);
+	return {
+		start: Math.max(unit.start, before + 1),
+		end: close === -1 ? unit.end : Math.min(unit.end, close)
 	};
 }
 function tokenize(blanked, bounds, kind) {
@@ -843,7 +1180,8 @@ function word(token) {
 function scan(text, cursor, kind) {
 	const noise = blankNoise(text, kind);
 	if (insideNoise(noise.spans, cursor)) return null;
-	return tokenize(noise.withNames, statementBounds(noise.blanked, cursor), kind);
+	const separators = statementSeparators(text, noise.blanked, kind);
+	return tokenize(noise.withNames, statementBounds(noise.blanked, separators, cursor), kind);
 }
 const TABLE_ANCHORS = /* @__PURE__ */ new Set([
 	"from",
@@ -1067,22 +1405,28 @@ function trimmedSpan(text, blanked, from, to) {
 		to: end
 	};
 }
-function statementSpans(text, blanked, from, to) {
+function statementSpans(text, blanked, separators, from, to) {
 	const spans = [];
 	let start = from;
-	for (let at = from; at <= to; at += 1) {
-		if (!(at === to || blanked[at] === ";")) continue;
-		const span = trimmedSpan(text, blanked, start, at);
+	const piece = (end) => {
+		const span = trimmedSpan(text, blanked, start, Math.max(start, end));
 		if (span !== null) spans.push(span);
-		start = at + 1;
+	};
+	for (const separator of separators) {
+		if (separator.to <= from) continue;
+		if (separator.from >= to) break;
+		piece(separator.from);
+		start = Math.min(Math.max(start, separator.to), to);
 	}
+	piece(to);
 	return spans;
 }
 function runnableStatement(text, from, to, kind) {
 	const { blanked } = blankNoise(text, kind);
+	const separators = statementSeparators(text, blanked, kind);
 	const selected = from < to;
-	const around = statementBounds(blanked, from);
-	const spans = selected ? statementSpans(text, blanked, from, to) : statementSpans(text, blanked, around.start, around.end);
+	const around = unitBounds(separators, from, text.length);
+	const spans = selected ? statementSpans(text, blanked, separators, from, to) : statementSpans(text, blanked, separators, around.start, around.end);
 	if (spans.length === 0) return { kind: "none" };
 	if (selected && spans.length > 1) return { kind: "several" };
 	const span = spans[0];
@@ -1093,7 +1437,7 @@ function runnableStatement(text, from, to, kind) {
 		blanked: blankNoise(statement, kind, "driver").blanked,
 		from: span.from,
 		to: span.to,
-		alone: statementSpans(text, blanked, 0, text.length).length <= 1
+		alone: statementSpans(text, blanked, separators, 0, text.length).length <= 1
 	};
 }
 function readIdentifier(text, offset, kind) {
@@ -1612,7 +1956,28 @@ const NATIVE_GROUP = {
 	kingbase: "dollarDigits",
 	clickhouse: null
 };
+const DEFINING = /* @__PURE__ */ new Set([
+	"CREATE",
+	"ALTER",
+	"DROP",
+	"COMMENT",
+	"RENAME",
+	"TRUNCATE",
+	"GRANT",
+	"REVOKE"
+]);
+const FIRST_WORD = /^\s*(?<word>[a-z_\u{0080}-\u{FFFF}][\w$\u{0080}-\u{FFFF}]*)/iu;
+function definesObjects(statement) {
+	const word = FIRST_WORD.exec(statement)?.groups?.word;
+	return word !== void 0 && DEFINING.has(word.toUpperCase());
+}
 function statementMarkers(statement, kind) {
+	if (definesObjects(statement)) return {
+		form: "none",
+		names: [],
+		count: 0,
+		refusal: null
+	};
 	const names = [];
 	const nativeGroup = NATIVE_GROUP[kind];
 	let count = 0;

package/dist/monaco.d.ts

@@ -1,4 +1,4 @@
-import { t as SqlAssist } from "./assist-Cr2idunB.js";
+import { t as SqlAssist } from "./assist-lygAVE0T.js";
 import * as monacoEditor from "monaco-editor";
 import { IDisposable } from "monaco-editor";
 //#region src/monaco.d.ts

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { t as SqlAssist } from "./assist-Cr2idunB.js";
+import { t as SqlAssist } from "./assist-lygAVE0T.js";
 import { ConsoleCaret, ConsoleEditorHandle, ConsoleEditorProps } from "@coldsmirk/inkstone-react/monaco";
 import { ReactNode } from "react";
 //#region src/react.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-sql",
-  "version": "0.34.2",
+  "version": "0.36.0",
   "description": "Schema-aware SQL editing intelligence for Monaco: lexical statement reading under per-dialect noise profiles, catalog-driven completion/hover/signature help, unified-placeholder awareness, formatting, and a drop-in React SQL editor.",
   "keywords": [
     "sql",
@@ -48,12 +48,12 @@
   "devDependencies": {
     "monaco-editor": "^0.57.0",
     "react": "^19.3.0",
-    "@coldsmirk/inkstone-react": "^0.34.2"
+    "@coldsmirk/inkstone-react": "^0.36.0"
   },
   "peerDependencies": {
     "monaco-editor": "^0.57.0",
     "react": ">=19",
-    "@coldsmirk/inkstone-react": "^0.34.2"
+    "@coldsmirk/inkstone-react": "^0.36.0"
   },
   "peerDependenciesMeta": {
     "@coldsmirk/inkstone-react": {