@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/src/client/presentation.js

@@ -0,0 +1,373 @@
+// src/client/presentation.ts
+import { isPart, text, thinking, tool } from "@nyte-ai/core";
+function showsTool(message) {
+  return isPart(message, tool);
+}
+function showsText(message) {
+  return isPart(message, text);
+}
+function showsThinking(message) {
+  return isPart(message, thinking);
+}
+function readRawPart(message) {
+  const { state } = message;
+  if (typeof state === "object" && state !== null && !Array.isArray(state)) {
+    const prose = "markdown" in state ? state.markdown : ("text" in state) ? state.text : undefined;
+    if (typeof prose === "string")
+      return { format: "text", body: prose };
+  }
+  return { format: "json", body: state === undefined ? "null" : JSON.stringify(state, null, 2) };
+}
+function showsReport(message) {
+  return message.source.kind === "child" || message.source.kind === "job";
+}
+function shownContent(message) {
+  return message.source.kind === "action" ? message.source.label : message.content;
+}
+var RUNNING = { tense: "running", tone: "running", word: undefined };
+function toolStatus(message) {
+  const { state, status } = message;
+  if (state.phase !== "settled") {
+    if (status.kind === "failed")
+      return status.failure.class === "aborted" ? { tense: "none", tone: "stopped", word: "Stopped" } : { tense: "none", tone: "stopped", word: "Interrupted" };
+    if (status.kind === "waiting" && status.on.kind === "part")
+      return { tense: "running", tone: "attention", word: "Needs input" };
+    return RUNNING;
+  }
+  switch (state.outcome.kind) {
+    case "ok":
+      return { tense: "past", tone: "success", word: undefined };
+    case "failed":
+      return { tense: "none", tone: "failure", word: "Failed" };
+    case "rejected":
+      return { tense: "none", tone: "failure", word: "Blocked" };
+    case "stopped":
+      return { tense: "none", tone: "stopped", word: "Stopped" };
+    case "interrupted":
+      return { tense: "none", tone: "stopped", word: "Interrupted" };
+    default: {
+      const _exhaustive = state.outcome;
+      return _exhaustive;
+    }
+  }
+}
+function toolOutput(state) {
+  if (state.phase !== "settled")
+    return "";
+  switch (state.outcome.kind) {
+    case "ok":
+      return state.outcome.content.flatMap((content) => content.kind === "text" && content.text !== "" ? [content.text] : []).join(`
+`);
+    case "failed":
+      return state.outcome.message;
+    case "rejected":
+      return state.outcome.reason;
+    case "stopped":
+    case "interrupted":
+      return "";
+    default: {
+      const _exhaustive = state.outcome;
+      return _exhaustive;
+    }
+  }
+}
+function executionMark(execution) {
+  switch (execution?.kind) {
+    case undefined:
+      return "idle";
+    case "idle":
+      return execution.lastRun?.end.kind === "failed" ? "failed" : "idle";
+    case "live":
+      return "working";
+    case "waiting":
+      return execution.on.kind === "part" ? "waiting" : "working";
+    case "retrying":
+      return "retry";
+    default: {
+      const _exhaustive = execution;
+      return _exhaustive;
+    }
+  }
+}
+function mainHead(session) {
+  return session.heads.find((head) => head.name === "main") ?? session.heads[0];
+}
+function sessionMark(session) {
+  return executionMark(mainHead(session)?.execution);
+}
+var COMMAND_ARGUMENT = /^[ \t]*\/([a-z0-9][a-z0-9-]*)[ \t]+/u;
+function findCommandArgument(value, cursor) {
+  const found = COMMAND_ARGUMENT.exec(value);
+  const command = found?.[1];
+  if (found === null || command === undefined || /[\r\n]/u.test(value))
+    return;
+  const start = found[0].length;
+  return cursor < start ? undefined : { command, start, query: value.slice(start, cursor) };
+}
+function completionTrigger(value, cursor = value.length) {
+  const caret = Math.max(0, Math.min(cursor, value.length));
+  let start = caret;
+  while (start > 0 && (value[start - 1] ?? "").trim() !== "")
+    start -= 1;
+  const kind = value[start];
+  if (start === caret || kind !== "@" && kind !== "/")
+    return;
+  let end = caret;
+  while (end < value.length && (value[end] ?? "").trim() !== "")
+    end += 1;
+  return { kind, start, end, query: value.slice(start + 1, caret) };
+}
+var RAN = { running: "Running", past: "Ran" };
+var CLASS_VERBS = {
+  read: { running: "Reading", past: "Read" },
+  list: { running: "Listing", past: "Listed" },
+  edit: { running: "Editing", past: "Edited" },
+  shell: RAN
+};
+var DELEGATE_VERBS = {
+  task: { running: "Delegating", past: "Delegated" },
+  create: { running: "Creating", past: "Created" },
+  send: { running: "Messaging", past: "Messaged" },
+  await: { running: "Waiting on", past: "Waited on" },
+  read: { running: "Reading transcript", past: "Read transcript" },
+  stop: { running: "Stopping", past: "Stopped" }
+};
+var DELEGATE_NOUNS = {
+  task: "agent",
+  create: "agent",
+  send: "message",
+  await: "wait",
+  read: "transcript",
+  stop: "stop"
+};
+var NAMED_TOOLS = new Map([
+  ["codemode", { verbs: { running: "Running script", past: "Ran script" } }],
+  ["tool_search", { verbs: { running: "Exploring", past: "Explored" }, detail: "available tools" }],
+  ["websearch", { verbs: { running: "Searching web", past: "Searched web" } }],
+  ["web_search", { verbs: { running: "Searching web", past: "Searched web" } }],
+  ["webfetch", { verbs: { running: "Fetching page", past: "Fetched page" } }],
+  ["web_fetch", { verbs: { running: "Fetching page", past: "Fetched page" } }],
+  ["rename_chat", { verbs: { running: "Renaming chat", past: "Renamed chat" } }],
+  ["browser_open", { verbs: { running: "Opening page", past: "Opened page" } }],
+  ["browser_click", { verbs: { running: "Clicking", past: "Clicked" } }],
+  ["browser_type", { verbs: { running: "Typing", past: "Typed" } }],
+  ["browser_press", { verbs: { running: "Pressing key", past: "Pressed key" } }],
+  ["browser_scroll", { verbs: { running: "Scrolling", past: "Scrolled" } }],
+  ["browser_wait", { verbs: { running: "Waiting", past: "Waited" } }],
+  ["browser_snapshot", { verbs: { running: "Taking snapshot", past: "Took snapshot" } }],
+  [
+    "browser_console",
+    { verbs: { running: "Checking console logs", past: "Checked console logs" } }
+  ],
+  ["browser_evaluate", { verbs: { running: "Executing JS", past: "Executed JS" } }]
+]);
+var MCP_LABEL = /^(?<server>[^:\s]+): (?<name>\S+)$/u;
+var MCP_NAME = /^mcp__(?<server>.+?)__(?<name>.+)$/u;
+function customTool(label) {
+  const named = NAMED_TOOLS.get(label);
+  if (named !== undefined)
+    return named;
+  const mcp = (MCP_LABEL.exec(label) ?? MCP_NAME.exec(label))?.groups;
+  if (mcp?.server !== undefined && mcp.name !== undefined)
+    return { verbs: RAN, name: mcp.name, server: mcp.server };
+  if (/\s/u.test(label))
+    return { verbs: { running: label, past: label } };
+  return { verbs: RAN, name: label };
+}
+function customDetail(custom) {
+  if (custom.name === undefined)
+    return custom.detail;
+  return custom.server === undefined ? custom.name : `${custom.name} in ${custom.server}`;
+}
+function toolVerbs(toolClass) {
+  switch (toolClass.kind) {
+    case "read":
+    case "list":
+    case "edit":
+    case "shell":
+      return CLASS_VERBS[toolClass.kind];
+    case "delegate":
+      return DELEGATE_VERBS[toolClass.role];
+    case "custom":
+      return customTool(toolClass.label).verbs;
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+function toolNoun(toolClass) {
+  switch (toolClass.kind) {
+    case "read":
+    case "list":
+    case "edit":
+      return toolClass.kind;
+    case "delegate":
+      return DELEGATE_NOUNS[toolClass.role];
+    case "shell":
+    case "custom":
+      return;
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+function delegateSubject(toolClass) {
+  return toolClass.title ?? "subagent";
+}
+function toolSubject(toolClass) {
+  switch (toolClass.kind) {
+    case "read":
+    case "list":
+    case "edit":
+      return toolClass.path;
+    case "shell":
+      return toolClass.command;
+    case "delegate":
+      return delegateSubject(toolClass);
+    case "custom":
+      return customDetail(customTool(toolClass.label));
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+function toolTitle(toolClass, tense, subject = toolSubject(toolClass)) {
+  if (tense !== "none") {
+    const verb = toolVerbs(toolClass)[tense];
+    return subject === undefined ? verb : `${verb} ${subject}`;
+  }
+  if (toolClass.kind === "custom" && customTool(toolClass.label).name === undefined)
+    return toolClass.label;
+  return [subject, toolNoun(toolClass)].filter((word) => word !== undefined).join(" ");
+}
+function tidyPath(path, cwd) {
+  if (cwd !== undefined && path.startsWith(`${cwd}/`))
+    return path.slice(cwd.length + 1);
+  return path;
+}
+function basename(path) {
+  return path.split(/[\\/]/u).at(-1) ?? path;
+}
+function placeName(path, cwd) {
+  const tidy = tidyPath(path, cwd);
+  if (tidy === "." || tidy === "./" || tidy === cwd)
+    return basename(cwd ?? tidy) || tidy;
+  return basename(tidy.replace(/[\\/]+$/u, "")) || tidy;
+}
+function condensedCommand(command, cwd) {
+  const compact = command.replaceAll(/\s+/gu, " ").trim();
+  if (cwd === undefined)
+    return compact;
+  const prefix = [cwd, `"${cwd}"`, `'${cwd}'`].flatMap((dir) => [`cd ${dir} && `, `cd ${dir}; `]).find((candidate) => compact.startsWith(candidate));
+  return prefix === undefined ? compact : compact.slice(prefix.length);
+}
+function formatDuration(ms) {
+  const seconds = Math.max(0, ms) / 1000;
+  if (seconds < 10)
+    return `${seconds.toFixed(1)}s`;
+  if (seconds < 60)
+    return `${String(Math.floor(seconds))}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${String(minutes)}m ${String(Math.floor(seconds % 60))}s`;
+  return `${String(Math.floor(minutes / 60))}h ${String(minutes % 60)}m`;
+}
+function formatWholeDuration(ms) {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0)
+    return minutes % 60 === 0 ? `${String(hours)}h` : `${String(hours)}h ${String(minutes % 60)}m`;
+  if (minutes > 0)
+    return seconds % 60 === 0 ? `${String(minutes)}m` : `${String(minutes)}m ${String(seconds % 60)}s`;
+  return `${String(seconds)}s`;
+}
+function toolDetail(toolClass, cwd) {
+  switch (toolClass.kind) {
+    case "edit": {
+      const title = tidyPath(toolClass.path, cwd);
+      return { text: basename(title), title };
+    }
+    case "read":
+    case "list":
+      return { text: placeName(toolClass.path, cwd), title: tidyPath(toolClass.path, cwd) };
+    case "shell":
+      return { text: condensedCommand(toolClass.command, cwd) };
+    case "delegate":
+      return { text: delegateSubject(toolClass) };
+    case "custom": {
+      const detail = customDetail(customTool(toolClass.label));
+      return detail === undefined ? undefined : { text: detail };
+    }
+    default: {
+      const _exhaustive = toolClass;
+      return _exhaustive;
+    }
+  }
+}
+var NOTICE_LIMIT = 180;
+function oneLine(message) {
+  const compact = message.replaceAll(/\s+/gu, " ").trim();
+  if (compact === "")
+    return;
+  return compact.length <= NOTICE_LIMIT ? compact : `${compact.slice(0, NOTICE_LIMIT - 1).trimEnd()}…`;
+}
+function danger(notice, recovery) {
+  return { text: notice, tone: "danger", recovery };
+}
+function failureNotice(failure) {
+  switch (failure.class) {
+    case "aborted":
+      return { text: "Run stopped.", tone: "neutral", recovery: undefined };
+    case "rate_limit":
+      return danger("Rate limit reached. Try again shortly.");
+    case "context_window":
+      return danger("This chat no longer fits the model's context window.", "compact");
+    case "quota":
+      return danger("Provider quota reached.", "switch-model");
+    case "auth":
+      return danger("The provider rejected the sign-in.", "sign-in");
+    case "overloaded":
+      return danger("The model is temporarily unavailable. Try again shortly.");
+    case "network":
+      return danger("Connection lost. Check your network and try again.");
+    case "provider":
+    case "runner":
+      return danger(oneLine(failure.message) ?? "Request failed.");
+    default: {
+      const _exhaustive = failure.class;
+      return _exhaustive;
+    }
+  }
+}
+export {
+  completionTrigger,
+  condensedCommand,
+  customTool,
+  delegateSubject,
+  executionMark,
+  failureNotice,
+  findCommandArgument,
+  formatDuration,
+  formatWholeDuration,
+  mainHead,
+  placeName,
+  readRawPart,
+  sessionMark,
+  shownContent,
+  showsReport,
+  showsText,
+  showsThinking,
+  showsTool,
+  tidyPath,
+  toolDetail,
+  toolNoun,
+  toolOutput,
+  toolStatus,
+  toolSubject,
+  toolTitle,
+  toolVerbs
+};

package/dist/src/client/transcript-tui.d.ts

@@ -0,0 +1,23 @@
+import type { Renderer } from "@nyte-ai/plugin/client";
+/**
+ * Renderers for the terminal client, as OpenTUI nodes: the five built-in
+ * part kinds. Feature plugins contribute their own renderers. A state its
+ * schema rejects draws nothing, for the client to show raw.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const transcriptRenderers: readonly Renderer[];
+/**
+ * The terminal renderers as a client plugin.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        renderers: readonly Renderer<import("@nyte-ai/plugin/client").PartDefinition<unknown, import("@nyte-ai/core").ActionSchemas>, unknown>[];
+    };
+};
+export default _default;

package/dist/src/client/transcript-tui.js

@@ -0,0 +1,20 @@
+// src/client/transcript-tui.ts
+import { Box, Text } from "@opentui/core";
+import { branchSummary, compaction, text, thinking, tool } from "@nyte-ai/plugin/client";
+import { defineRenderer } from "@nyte-ai/plugin/client";
+var unreadable = () => null;
+var transcriptRenderers = [
+  defineRenderer(text, "tui", (state) => Text({ content: state.markdown }), unreadable),
+  defineRenderer(thinking, "tui", (state) => Text({ content: `Thinking: ${state.markdown}` }), unreadable),
+  defineRenderer(tool, "tui", (state, act) => Box({ flexDirection: "row", gap: 1 }, Text({ content: state.class.kind === "custom" ? state.class.label : state.name }), state.phase === "settled" ? Text({ content: state.outcome.kind }) : Text({ content: "[stop]", onMouseDown: () => void act("stop", {}) })), unreadable),
+  defineRenderer(compaction, "tui", (state) => Text({ content: state.summary ?? `Context compacted at ${state.tokensBefore} tokens.` }), unreadable),
+  defineRenderer(branchSummary, "tui", (state) => Text({ content: `Branch summary: ${state.markdown}` }), unreadable)
+];
+var transcript_tui_default = {
+  id: "transcript-tui",
+  contribute: { renderers: transcriptRenderers }
+};
+export {
+  transcript_tui_default as default,
+  transcriptRenderers
+};

package/dist/src/client/transcript.d.ts

@@ -0,0 +1,23 @@
+import type { Renderer } from "@nyte-ai/plugin/client";
+/**
+ * Renderers for React clients, the desktop and the web: the five built-in
+ * part kinds. The tool's Stop action calls `act`. A state its schema rejects
+ * draws nothing, for the client to show raw.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare const transcriptRenderers: readonly Renderer[];
+/**
+ * The React renderers as a client plugin.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: {
+    id: string;
+    contribute: {
+        renderers: readonly Renderer<import("@nyte-ai/plugin/client").PartDefinition<unknown, import("@nyte-ai/core").ActionSchemas>, unknown>[];
+    };
+};
+export default _default;

package/dist/src/client/transcript.js

@@ -0,0 +1,51 @@
+// src/client/transcript.tsx
+import { branchSummary, compaction, text, thinking, tool } from "@nyte-ai/plugin/client";
+import { defineRenderer } from "@nyte-ai/plugin/client";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var unreadable = () => null;
+var transcriptRenderers = [
+  defineRenderer(text, "react", (state) => /* @__PURE__ */ jsxDEV("div", {
+    "data-part": "text",
+    children: state.markdown
+  }, undefined, false, undefined, this), unreadable),
+  defineRenderer(thinking, "react", (state) => /* @__PURE__ */ jsxDEV("details", {
+    "data-part": "thinking",
+    children: [
+      /* @__PURE__ */ jsxDEV("summary", {
+        children: "Thinking"
+      }, undefined, false, undefined, this),
+      state.markdown
+    ]
+  }, undefined, true, undefined, this), unreadable),
+  defineRenderer(tool, "react", (state, act) => /* @__PURE__ */ jsxDEV("div", {
+    "data-part": "tool",
+    "data-phase": state.phase,
+    children: [
+      /* @__PURE__ */ jsxDEV("span", {
+        children: state.class.kind === "custom" ? state.class.label : state.name
+      }, undefined, false, undefined, this),
+      state.phase === "settled" ? /* @__PURE__ */ jsxDEV("span", {
+        children: state.outcome.kind
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV("button", {
+        onClick: () => void act("stop", {}),
+        children: "Stop"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this), unreadable),
+  defineRenderer(compaction, "react", (state) => /* @__PURE__ */ jsxDEV("div", {
+    "data-part": "compaction",
+    children: state.summary ?? `Context compacted at ${state.tokensBefore} tokens.`
+  }, undefined, false, undefined, this), unreadable),
+  defineRenderer(branchSummary, "react", (state) => /* @__PURE__ */ jsxDEV("div", {
+    "data-part": "branchSummary",
+    children: state.markdown
+  }, undefined, false, undefined, this), unreadable)
+];
+var transcript_default = {
+  id: "transcript",
+  contribute: { renderers: transcriptRenderers }
+};
+export {
+  transcript_default as default,
+  transcriptRenderers
+};

package/dist/src/client.d.ts

@@ -0,0 +1,53 @@
+import type { Part, PartDefinition, PartState, Renderer } from "@nyte-ai/core";
+import type { HookEntry as SideHookEntry, HookHandler as SideHookHandler, HookName as SideHookName, Plugin as CorePlugin, PluginApi as CorePluginApi } from "@nyte-ai/core";
+export { branchSummary, compaction, definePart, isPart, text, thinking, tool } from "@nyte-ai/core";
+export type { ClientApi, Command, Keybinding, Part, PartDefinition, PartState, Renderer, SettingDefinition, } from "@nyte-ai/core";
+/**
+ * A client plugin: once per app, with renderers, commands, settings,
+ * keybindings and client hooks. It declares the frameworks it renders for;
+ * the client mounts what it can.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type Plugin = CorePlugin<"client">;
+/**
+ * What a client plugin's `activate` and hook handlers receive: the app's
+ * connection, the session on screen and notifications.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export type PluginApi = CorePluginApi<"client">;
+/**
+ * Names a hook a client plugin may handle.
+ *
+ * @category hooks
+ * @since 0.1.0
+ */
+export type HookName = SideHookName<"client">;
+/**
+ * Returns a client hook handler's signature.
+ *
+ * @category hooks
+ * @since 0.1.0
+ */
+export type HookHandler<N extends HookName> = SideHookHandler<"client", N>;
+/**
+ * Returns a client hook entry: a handler, or a handler with an order.
+ *
+ * @category hooks
+ * @since 0.1.0
+ */
+export type HookEntry<N extends HookName> = SideHookEntry<"client", N>;
+/**
+ * Returns a renderer for one part kind whose `draw` gets the state checked
+ * against the kind's schema, typed; a state the schema rejects draws
+ * `unreadable`. The untyped `Renderer` is what a client mounts: a typed
+ * `Renderer<K>` is not assignable to it while the untyped `act` carries no
+ * action outputs (Part 2 §32), so the check is also the narrowing.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function defineRenderer<K extends PartDefinition, View>(kind: K, framework: string, draw: (state: PartState<K>, act: Part<PartDefinition>["act"]) => View, unreadable: (kind: string) => View): Renderer;

package/dist/src/client.js

@@ -0,0 +1,22 @@
+// src/client.ts
+import { branchSummary, compaction, definePart, isPart, text, thinking, tool } from "@nyte-ai/core";
+function defineRenderer(kind, framework, draw, unreadable) {
+  return {
+    kind,
+    framework,
+    render(part, act) {
+      const checked = kind.state["~standard"].validate(part.state);
+      return checked instanceof Promise || checked.issues !== undefined ? unreadable(kind.kind) : draw(checked.value, act);
+    }
+  };
+}
+export {
+  branchSummary,
+  compaction,
+  definePart,
+  defineRenderer,
+  isPart,
+  text,
+  thinking,
+  tool
+};

package/dist/src/codemode-runtime.d.ts

@@ -0,0 +1,11 @@
+export { loadQuickJSWasm } from "@earendil-works/pi-codemode";
+export type { CodemodeSandboxOptions } from "@earendil-works/pi-codemode";
+/**
+ * Returns the path of the QuickJS wasm the codemode sandbox loads, for a
+ * bundler that copies it next to its output. Node only: it resolves through
+ * `node:module`.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function resolveQuickJSWasmPath(): string;

package/dist/src/codemode-runtime.js

@@ -0,0 +1,10 @@
+// src/codemode-runtime.ts
+import { createRequire } from "node:module";
+import { loadQuickJSWasm } from "@earendil-works/pi-codemode";
+function resolveQuickJSWasmPath() {
+  return createRequire(import.meta.resolve("@earendil-works/pi-codemode")).resolve("quickjs-wasi/quickjs.wasm");
+}
+export {
+  loadQuickJSWasm,
+  resolveQuickJSWasmPath
+};

package/dist/src/codemode-worker.d.ts

@@ -0,0 +1 @@
+export {} from "@earendil-works/pi-codemode/worker";

package/dist/src/codemode-worker.js

@@ -0,0 +1,2 @@
+// src/codemode-worker.ts
+import"@earendil-works/pi-codemode/worker";

package/dist/src/codemode.d.ts

@@ -0,0 +1,21 @@
+import type { CodemodeSandboxOptions } from "@earendil-works/pi-codemode";
+import type { Plugin } from "@nyte-ai/plugin/core";
+/**
+ * Returns the codemode plugin with the sandbox runtime a bundled client
+ * passes (its worker entry and wasm); the default export uses the installed
+ * package's own. The `codemode` tool runs a script in a QuickJS worker whose
+ * only capability is calling the session's tools through
+ * `invocation.tools.execute`, including those exposed to code only.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+export declare function codemodePlugin(runtime: Pick<CodemodeSandboxOptions, "workerUrl" | "wasm">): Plugin;
+/**
+ * The codemode plugin over the installed sandbox runtime.
+ *
+ * @category plugins
+ * @since 0.1.0
+ */
+declare const _default: Plugin;
+export default _default;