@mcp-b/interactive-components 0.2.0

package/dist/code-preview-gKk0nBKP.js

@@ -0,0 +1,269 @@
+import { t as __decorate } from "./decorate-DcF3lt7P.js";
+import { buildHtmlPreview, buildModulePreview, buildPythonPayload, detectLanguage } from "./lib/transform.js";
+import { RUNNER_CONNECT_TYPE, bindRunnerUrl, connectRunner, createRunnerChannelId, isRecord, parseRunnerConsoleMessage } from "./lib/runner-channel.js";
+import { getRunnerUrl } from "./lib/runner-url.js";
+import { css, html } from "lit";
+import { property, state } from "lit/decorators.js";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+import hostStyles from "@mcp-b/wc-support/styles/host.styles";
+import "@mcp-b/web-components/components/callout/callout.js";
+import "@mcp-b/web-components/components/spinner/spinner.js";
+//#region src/components/code-preview/code-preview.styles.ts
+var code_preview_styles_default = css`
+  :host {
+    display: flex;
+    flex-direction: column;
+    position: relative;
+    background: var(--sigvelo-interactive-preview-bg, #fff);
+    height: 100%;
+    overflow: hidden;
+  }
+
+  .preview-iframe {
+    flex: 1;
+    width: 100%;
+    border: none;
+    background: var(--sigvelo-interactive-preview-bg, #fff);
+  }
+
+  .loading {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--sigvelo-interactive-preview-bg, #fff);
+    z-index: 5;
+  }
+
+  .error {
+    position: absolute;
+    inset: 0;
+    overflow: auto;
+    padding: 16px;
+    z-index: 10;
+  }
+`;
+//#endregion
+//#region src/components/code-preview/code-preview.ts
+/**
+* `<sigvelo-code-preview>`
+*
+* @summary A sandboxed preview pane that transpiles and runs code from a set of
+* files. Supports HTML entry points (with inlined CSS/JS) and module entry
+* points (TS/TSX via esm.sh). Displays errors using `<sigvelo-callout>`.
+*
+* @tag sigvelo-code-preview
+* @status experimental
+* @since 0.1
+*
+* @event sigvelo-run - Fires when execution completes successfully.
+* @event sigvelo-error - Fires when a build or runtime error occurs. `event.detail.message` has the error text.
+* @event sigvelo-console - Fires for validated console output from the isolated preview.
+*/
+var SigveloCodePreview = class SigveloCodePreview extends SigveloElement {
+	constructor(..._args) {
+		super(..._args);
+		this.files = [];
+		this.entryFile = "";
+		this.captureConsole = false;
+		this._srcdoc = "";
+		this._pyRunnerSrc = "";
+		this._error = null;
+		this._loading = false;
+		this._blobUrls = [];
+		this._pendingPyPayload = null;
+		this._runnerPort = null;
+		this._runnerChannelId = createRunnerChannelId();
+	}
+	static {
+		this.styles = [hostStyles, code_preview_styles_default];
+	}
+	static {
+		this.CONSOLE_CAPTURE_SCRIPT = `<script>
+(function() {
+  var _port = null;
+  var _queuedMessages = [];
+  var _connect = function(event) {
+    if (event.source !== parent ||
+        event.origin !== '__SIGVELO_PARENT_ORIGIN__' ||
+        !event.data ||
+        event.data.type !== ${JSON.stringify(RUNNER_CONNECT_TYPE)} ||
+        event.data.channelId !== '__SIGVELO_CHANNEL_ID__' ||
+        event.data.parentOrigin !== '__SIGVELO_PARENT_ORIGIN__' ||
+        event.ports.length !== 1) return;
+    _port = event.ports[0];
+    _port.start();
+    _queuedMessages.forEach(function(message) { _port.postMessage(message); });
+    _queuedMessages = [];
+    window.removeEventListener('message', _connect);
+  };
+  window.addEventListener('message', _connect);
+  var _post = function(level, args) {
+    try {
+      var message = { __sigvelo_console: true, level: level, args: args.map(function(a) {
+        try { return typeof a === 'object' ? JSON.stringify(a, null, 2) : String(a); }
+        catch(e) { return String(a); }
+      }), ts: Date.now() };
+      if (_port) _port.postMessage(message);
+      else if (_queuedMessages.length < 100) _queuedMessages.push(message);
+    } catch(e) {}
+  };
+  ['log','warn','error','info'].forEach(function(m) {
+    var orig = console[m];
+    console[m] = function() {
+      var args = Array.prototype.slice.call(arguments);
+      _post(m, args);
+      orig.apply(console, args);
+    };
+  });
+  window.addEventListener('error', function(e) {
+    _post('error', [e.message + ' at ' + e.filename + ':' + e.lineno]);
+  });
+})();
+<\/script>`;
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback();
+		this._runnerPort?.close();
+		this._runnerPort = null;
+		this._revokeBlobUrls();
+	}
+	_onRunnerMessage(data) {
+		if (isRecord(data) && data.__sigvelo_pyscript_ready === true && this._pendingPyPayload) {
+			this._postPyPayload();
+			return;
+		}
+		const consoleMessage = parseRunnerConsoleMessage(data);
+		if (consoleMessage) this.dispatchEvent(new CustomEvent("sigvelo-console", {
+			bubbles: true,
+			composed: true,
+			detail: consoleMessage
+		}));
+	}
+	_postPyPayload() {
+		if (!this._pendingPyPayload) return;
+		this._runnerPort?.postMessage(this._pendingPyPayload);
+	}
+	_connectRunner(event) {
+		if (!(event.currentTarget instanceof HTMLIFrameElement)) return;
+		this._runnerPort?.close();
+		this._runnerPort = connectRunner(event.currentTarget, this._runnerChannelId, (data) => this._onRunnerMessage(data));
+	}
+	/** Build and display the current file set. */
+	async run() {
+		this._revokeBlobUrls();
+		this._loading = true;
+		this._error = null;
+		try {
+			const fileMap = /* @__PURE__ */ new Map();
+			for (const f of this.files) fileMap.set(f.name, {
+				name: f.name,
+				content: f.content,
+				language: f.language ?? detectLanguage(f.name)
+			});
+			const entry = this._resolveEntry(fileMap);
+			const entryLang = detectLanguage(entry);
+			if (entryLang === "python") {
+				this._pendingPyPayload = buildPythonPayload(fileMap, entry);
+				this._srcdoc = "";
+				const runnerUrl = bindRunnerUrl(getRunnerUrl("pyscript"), this._runnerChannelId).href;
+				if (this._pyRunnerSrc === runnerUrl) this._postPyPayload();
+				else this._pyRunnerSrc = runnerUrl;
+			} else if (entryLang === "html") {
+				this._pyRunnerSrc = "";
+				this._srcdoc = this._injectConsoleCapture(await buildHtmlPreview(fileMap));
+				this._blobUrls = [];
+			} else {
+				this._pyRunnerSrc = "";
+				const result = await buildModulePreview(fileMap, entry);
+				this._srcdoc = this._injectConsoleCapture(result.html);
+				this._blobUrls = result.blobUrls;
+			}
+			this.dispatchEvent(new CustomEvent("sigvelo-run", {
+				bubbles: true,
+				composed: true
+			}));
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this._error = message;
+			this.dispatchEvent(new CustomEvent("sigvelo-error", {
+				bubbles: true,
+				composed: true,
+				detail: { message }
+			}));
+		} finally {
+			this._loading = false;
+		}
+	}
+	_resolveEntry(fileMap) {
+		if (this.entryFile && fileMap.has(this.entryFile)) return this.entryFile;
+		for (const name of [
+			"index.html",
+			"index.tsx",
+			"index.ts",
+			"index.jsx",
+			"index.js",
+			"main.tsx",
+			"main.ts",
+			"main.py",
+			"index.py",
+			"main.r",
+			"script.r"
+		]) if (fileMap.has(name)) return name;
+		return fileMap.keys().next().value ?? "";
+	}
+	_revokeBlobUrls() {
+		for (const url of this._blobUrls) URL.revokeObjectURL(url);
+		this._blobUrls = [];
+	}
+	/** Injects the console capture script before </body> if captureConsole is enabled. */
+	_injectConsoleCapture(markup) {
+		if (!this.captureConsole) return markup;
+		const captureScript = SigveloCodePreview.CONSOLE_CAPTURE_SCRIPT.replaceAll("__SIGVELO_CHANNEL_ID__", this._runnerChannelId).replaceAll("__SIGVELO_PARENT_ORIGIN__", window.location.origin);
+		const idx = markup.lastIndexOf("</body>");
+		if (idx === -1) return markup + captureScript;
+		return markup.slice(0, idx) + captureScript + markup.slice(idx);
+	}
+	render() {
+		return html`
+      ${this._loading ? html` <div class="loading"><sigvelo-spinner label="Building…"></sigvelo-spinner></div> ` : ""}
+      ${this._error ? html`
+            <div class="error">
+              <sigvelo-callout color="destructive">
+                <sigvelo-icon slot="icon" name="alert-triangle"></sigvelo-icon>
+                <pre style="margin:0; white-space:pre-wrap; word-break:break-word; font-size:12px;">
+${this._error}</pre
+                >
+              </sigvelo-callout>
+            </div>
+          ` : ""}
+      ${this._pyRunnerSrc ? html`<iframe
+            class="preview-iframe"
+            sandbox="allow-scripts allow-modals allow-forms"
+            title="Code preview"
+            .src=${this._pyRunnerSrc}
+            @load=${this._connectRunner}
+          ></iframe>` : html`<iframe
+            class="preview-iframe"
+            sandbox="allow-scripts allow-modals allow-forms"
+            title="Code preview"
+            .srcdoc=${this._srcdoc}
+            @load=${this._connectRunner}
+          ></iframe>`}
+    `;
+	}
+};
+__decorate([property({ type: Array })], SigveloCodePreview.prototype, "files", void 0);
+__decorate([property({ attribute: "entry-file" })], SigveloCodePreview.prototype, "entryFile", void 0);
+__decorate([property({
+	attribute: "capture-console",
+	type: Boolean
+})], SigveloCodePreview.prototype, "captureConsole", void 0);
+__decorate([state()], SigveloCodePreview.prototype, "_srcdoc", void 0);
+__decorate([state()], SigveloCodePreview.prototype, "_pyRunnerSrc", void 0);
+__decorate([state()], SigveloCodePreview.prototype, "_error", void 0);
+__decorate([state()], SigveloCodePreview.prototype, "_loading", void 0);
+customElements.define("sigvelo-code-preview", SigveloCodePreview);
+//#endregion
+export { SigveloCodePreview as t };

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

@@ -0,0 +1,65 @@
+import { n as FileLanguage } from "../../transform-DWhHlnkw.js";
+import { CSSResultGroup, PropertyValues } from "lit";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+import { EditorView } from "@codemirror/view";
+
+//#region src/components/code-editor/code-editor.d.ts
+/**
+ * `<sigvelo-code-editor>`
+ *
+ * @summary A CodeMirror 6 wrapper that provides syntax-highlighted editing for
+ * a single document. Supports JavaScript, TypeScript, JSX, TSX, HTML, and CSS.
+ * Automatically detects dark mode from the `data-theme` attribute on the
+ * document root and applies the One Dark CodeMirror theme accordingly.
+ *
+ * @tag sigvelo-code-editor
+ * @status experimental
+ * @since 0.1
+ *
+ * @event sigvelo-change - Fires when the document content changes. `event.detail.value` contains the new content.
+ */
+declare class SigveloCodeEditor extends SigveloElement {
+  static styles: CSSResultGroup;
+  /** The document content. */
+  value: string;
+  /** Syntax highlighting language. */
+  language: FileLanguage;
+  /** Makes the editor read-only. */
+  readonly: boolean;
+  /** Accessible label for the editor. */
+  editorLabel: string;
+  /**
+   * The name exposed to assistive technology. CodeMirror renders a
+   * `role="textbox"` element, which must always be named, so an unset
+   * `editor-label` falls back to the language rather than leaving it anonymous.
+   */
+  private get accessibleLabel();
+  private _host;
+  private _dark;
+  private _view;
+  private _langCompartment;
+  private _themeCompartment;
+  private _readonlyCompartment;
+  private _labelCompartment;
+  private _suppressExternalUpdate;
+  private _themeObserver;
+  private _systemTheme;
+  private _onSystemThemeChange;
+  connectedCallback(): void;
+  protected firstUpdated(): void;
+  protected updated(changed: PropertyValues): void;
+  disconnectedCallback(): void;
+  private _isDark;
+  private _observeTheme;
+  private _createView;
+  /** Returns the underlying CodeMirror `EditorView`, or `null` if not yet created. */
+  getEditorView(): EditorView | null;
+  protected render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-code-editor": SigveloCodeEditor;
+  }
+}
+//#endregion
+export { SigveloCodeEditor };

package/dist/components/code-editor/code-editor.js

@@ -0,0 +1,2 @@
+import { t as SigveloCodeEditor } from "../../code-editor-B94tewLC.js";
+export { SigveloCodeEditor };

package/dist/components/code-preview/code-preview.d.ts

@@ -0,0 +1,58 @@
+import { t as EditorFile } from "../../transform-DWhHlnkw.js";
+import { CSSResultGroup } from "lit";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+//#region src/components/code-preview/code-preview.d.ts
+/**
+ * `<sigvelo-code-preview>`
+ *
+ * @summary A sandboxed preview pane that transpiles and runs code from a set of
+ * files. Supports HTML entry points (with inlined CSS/JS) and module entry
+ * points (TS/TSX via esm.sh). Displays errors using `<sigvelo-callout>`.
+ *
+ * @tag sigvelo-code-preview
+ * @status experimental
+ * @since 0.1
+ *
+ * @event sigvelo-run - Fires when execution completes successfully.
+ * @event sigvelo-error - Fires when a build or runtime error occurs. `event.detail.message` has the error text.
+ * @event sigvelo-console - Fires for validated console output from the isolated preview.
+ */
+declare class SigveloCodePreview extends SigveloElement {
+  static styles: CSSResultGroup;
+  /** The file set to render. */
+  files: EditorFile[];
+  /**
+   * The name of the entry file. Defaults to `index.html` if present,
+   * otherwise the first `.tsx`, `.ts`, `.jsx`, or `.js` file.
+   */
+  entryFile: string;
+  /** When true, injects a console capture script into the iframe srcdoc. */
+  captureConsole: boolean;
+  private _srcdoc;
+  private _pyRunnerSrc;
+  private _error;
+  private _loading;
+  private _blobUrls;
+  private _pendingPyPayload;
+  private _runnerPort;
+  private readonly _runnerChannelId;
+  private static readonly CONSOLE_CAPTURE_SCRIPT;
+  disconnectedCallback(): void;
+  private _onRunnerMessage;
+  private _postPyPayload;
+  private _connectRunner;
+  /** Build and display the current file set. */
+  run(): Promise<void>;
+  private _resolveEntry;
+  private _revokeBlobUrls;
+  /** Injects the console capture script before </body> if captureConsole is enabled. */
+  private _injectConsoleCapture;
+  protected render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-code-preview": SigveloCodePreview;
+  }
+}
+//#endregion
+export { SigveloCodePreview };

package/dist/components/code-preview/code-preview.js

@@ -0,0 +1,3 @@
+import "../../lib/transform.js";
+import { t as SigveloCodePreview } from "../../code-preview-gKk0nBKP.js";
+export { SigveloCodePreview };

package/dist/components/interactive-editor/interactive-editor.d.ts

@@ -0,0 +1,77 @@
+import { t as EditorFile } from "../../transform-DWhHlnkw.js";
+import { CSSResultGroup, PropertyValues } from "lit";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+//#region src/components/interactive-editor/interactive-editor.d.ts
+/**
+ * `<sigvelo-interactive-editor>`
+ *
+ * @summary A multi-file code playground with a collapsible file explorer
+ * sidebar, code editor, and live preview/console pane. The sidebar sits
+ * beside the editor only and does not extend into the preview pane.
+ *
+ * @tag sigvelo-interactive-editor
+ * @status experimental
+ * @since 0.1
+ * @cssproperty [--sigvelo-interactive-editor-height=30rem] - The editor's block size.
+ */
+declare class SigveloInteractiveEditor extends SigveloElement {
+  static styles: CSSResultGroup;
+  files: EditorFile[];
+  entryFile: string;
+  layout: "horizontal" | "vertical";
+  hideEditor: boolean;
+  hidePreview: boolean;
+  autoRun: boolean;
+  private _activeFileName;
+  private _fileContents;
+  private _showAddFile;
+  private _newFileName;
+  private _fileError;
+  private _compact;
+  private _compactView;
+  private _rightPane;
+  private _consoleLogs;
+  private _unreadConsoleCount;
+  private _sidebarOpen;
+  private _expandedFolders;
+  private _preview;
+  private _runDebounce;
+  private _resizeObserver;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  protected willUpdate(changed: PropertyValues): void;
+  protected updated(changed: PropertyValues): void;
+  private _onConsoleMessage;
+  private _clearConsole;
+  private _initFiles;
+  private _activeContent;
+  private _activeLanguage;
+  private _onEditorChange;
+  private _scheduleRun;
+  private _runCode;
+  /** Returns the runtime language of the project ('python', 'r', or 'js'). */
+  private _projectRuntime;
+  private _confirmAddFile;
+  private _dismissAddFile;
+  private _removeFile;
+  private _switchView;
+  private _selectFileAndShowCode;
+  private _switchRightPane;
+  private _toggleFolder;
+  private _renderTreeNodes;
+  private _renderSidebar;
+  private _renderEditorPane;
+  private _renderRightPane;
+  private _renderConsoleView;
+  private _renderMobileNav;
+  private _renderMobileFileList;
+  private _renderContent;
+  protected render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-interactive-editor": SigveloInteractiveEditor;
+  }
+}
+//#endregion
+export { SigveloInteractiveEditor };

package/dist/components/interactive-editor/interactive-editor.js

@@ -0,0 +1,3 @@
+import "../../lib/transform.js";
+import { t as SigveloInteractiveEditor } from "../../interactive-editor-WfTWxJGF.js";
+export { SigveloInteractiveEditor };

package/dist/components/r-editor/r-editor.d.ts

@@ -0,0 +1,68 @@
+import { CSSResultGroup } from "lit";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+//#region src/components/r-editor/r-editor.d.ts
+/**
+ * `<sigvelo-r-editor>`
+ *
+ * @summary A WebR-powered R code editor with integrated console output and plot
+ * viewer. Runs R code in the browser via WebAssembly. The editor pane uses
+ * CodeMirror with R syntax highlighting, while the right pane shows captured
+ * plots and console output in separate tabs.
+ *
+ * @tag sigvelo-r-editor
+ * @status experimental
+ * @since 0.1
+ */
+declare class SigveloREditor extends SigveloElement {
+  static styles: CSSResultGroup;
+  /** Initial R code to display in the editor. */
+  code: string;
+  /** R packages to pre-install before running code (e.g. `['ggplot2']`). */
+  packages: string[];
+  /** Accessible label for the editor. */
+  editorLabel: string;
+  private _editedCode;
+  private _consoleLogs;
+  private _plots;
+  private _currentPlotIndex;
+  private _webRReady;
+  private _webRLoading;
+  private _loadingMessage;
+  private _running;
+  private _compact;
+  private _compactView;
+  private _rightPane;
+  private _unreadConsoleCount;
+  private _resizeObserver;
+  private _runnerIframe;
+  private _runnerPort;
+  private readonly _runnerChannelId;
+  connectedCallback(): void;
+  protected firstUpdated(): void;
+  disconnectedCallback(): void;
+  private _initRunner;
+  private _onMessage;
+  private _runCode;
+  private _onEditorChange;
+  private _prevPlot;
+  private _nextPlot;
+  private _savePlot;
+  private _clearPlots;
+  private _clearConsole;
+  private _switchRightPane;
+  private _switchView;
+  private _renderEditorPane;
+  private _renderPlotViewer;
+  private _renderConsoleView;
+  private _renderRightPane;
+  private _renderLoadingOverlay;
+  private _renderMobileNav;
+  protected render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-r-editor": SigveloREditor;
+  }
+}
+//#endregion
+export { SigveloREditor };

package/dist/components/r-editor/r-editor.js

@@ -0,0 +1,2 @@
+import { t as SigveloREditor } from "../../r-editor-DwSyDo2i.js";
+export { SigveloREditor };

package/dist/components/sql-editor/sql-editor.d.ts

@@ -0,0 +1,78 @@
+import { CSSResultGroup } from "lit";
+import { SigveloElement } from "@mcp-b/wc-support/base/sigvelo-element";
+//#region src/components/sql-editor/sql-editor.d.ts
+/**
+ * `<sigvelo-sql-editor>`
+ *
+ * @summary An in-browser PostgreSQL editor powered by PGlite (WASM). Runs
+ * SQL queries locally with no server. Includes a results table, schema
+ * browser with autocompletion, and optional dataset preloading via the
+ * `setup-sql` attribute.
+ *
+ * @tag sigvelo-sql-editor
+ * @status experimental
+ * @since 0.1
+ */
+declare class SigveloSqlEditor extends SigveloElement {
+  static styles: CSSResultGroup;
+  /** SQL to execute on database initialization (CREATE TABLE, INSERT, etc.). */
+  setupSql: string;
+  /** Initial query in the editor. */
+  code: string;
+  /** IndexedDB name for persistence. Empty = in-memory (no persistence). */
+  dbName: string;
+  /** Enable PostGIS extension on the in-browser database. */
+  postgis: boolean;
+  /** Accessible label for the editor. */
+  editorLabel: string;
+  private _editedCode;
+  private _pgliteReady;
+  private _pgliteLoading;
+  private _loadingMessage;
+  private _running;
+  private _resultFields;
+  private _resultRows;
+  private _rowCount;
+  private _executionTimeMs;
+  private _error;
+  private _schema;
+  private _expandedTables;
+  private _sortColumn;
+  private _sortDirection;
+  private _compact;
+  private _compactView;
+  private _rightPane;
+  private _runner;
+  private _resizeObserver;
+  private _execId;
+  connectedCallback(): void;
+  protected firstUpdated(): void;
+  disconnectedCallback(): void;
+  private _initRunner;
+  private _postToRunner;
+  private _onMessage;
+  private _requestSchema;
+  private _runCode;
+  private _onEditorChange;
+  private _resetDatabase;
+  private _boundOnKeydown;
+  private _onKeydown;
+  private _toggleTable;
+  private _insertSelectQuery;
+  private _toggleSort;
+  private _getSortedRows;
+  private _renderEditorPane;
+  private _renderResultsView;
+  private _renderSchemaView;
+  private _renderRightPane;
+  private _renderLoadingOverlay;
+  private _renderMobileNav;
+  protected render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "sigvelo-sql-editor": SigveloSqlEditor;
+  }
+}
+//#endregion
+export { SigveloSqlEditor };

package/dist/components/sql-editor/sql-editor.js

@@ -0,0 +1,2 @@
+import { t as SigveloSqlEditor } from "../../sql-editor-CsNrjJ2_.js";
+export { SigveloSqlEditor };

package/dist/decorate-DcF3lt7P.js

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.138.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+export { __decorate as t };