@cocoar/vue-script-editor 1.9.0-script-editor.4

package/dist/composables/useFormFieldContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormFieldContext.d.ts","sourceRoot":"","sources":["../../src/composables/useFormFieldContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,WAAW,EAAqB,MAAM,KAAK,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC/B,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CAChC;AAMD,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,SAAS,CAElE"}

package/dist/composables/useMonacoEditor.d.ts

@@ -0,0 +1,58 @@
+import { Ref } from 'vue';
+import { CoarScriptEditorTheme } from '../theme';
+import * as monaco from 'monaco-editor';
+export type CoarScriptEditorLanguage = 'typescript' | 'javascript' | 'json';
+export type CoarScriptEditorVariant = 'editor' | 'inline';
+export interface UseMonacoEditorOptions {
+    host: Ref<HTMLElement | null>;
+    initialValue: () => string;
+    language: () => CoarScriptEditorLanguage;
+    readonly: () => boolean;
+    minimap: () => boolean;
+    theme: () => CoarScriptEditorTheme;
+    variant?: () => CoarScriptEditorVariant;
+    /**
+     * Hidden + locked prefix prepended to the model content for per-editor type context.
+     * `setHiddenAreas` hides it from view, and an internal guard rejects any edit whose
+     * change offset falls inside the preamble range. Emitted value is the user-script
+     * portion only — preamble never round-trips through `modelValue`.
+     */
+    preamble?: () => string;
+    /**
+     * When true, sets `diagnosticCodesToIgnore` on Monaco's TS/JS defaults to suppress the
+     * errors that normally fire on "script body" code (top-level return/await/export, etc).
+     * **Global side-effect** — affects all TS/JS editors on the page. Consumers needing
+     * granular control should manage `monaco.languages.typescript.typescriptDefaults`
+     * directly.
+     */
+    scriptMode?: () => boolean;
+    autofocus?: () => boolean;
+    /**
+     * Optional override for where Monaco renders overflow widgets (IntelliSense popups,
+     * hover, parameter hints). When the editor is mounted inside a modal/overlay with its
+     * own stacking context, the default body-level container often ends up behind the modal
+     * or in the wrong stacking context. Pass an element from inside the modal to put the
+     * widgets there. Returning `null` means "use Monaco's default body-level container".
+     */
+    overflowWidgetsDomNode?: () => HTMLElement | null;
+    onContentChange: (value: string) => void;
+    onFocused?: () => void;
+    onBlurred?: () => void;
+    onEditorReady?: (editor: monaco.editor.IStandaloneCodeEditor) => void;
+}
+export interface UseMonacoEditorResult {
+    editor: Readonly<Ref<monaco.editor.IStandaloneCodeEditor | null>>;
+    model: Readonly<Ref<monaco.editor.ITextModel | null>>;
+    /**
+     * Replace the editor value without re-emitting a change event. Used for external v-model updates.
+     */
+    setValue: (value: string) => void;
+    /**
+     * Temporarily suppresses `onContentChange` callbacks during the given mutation. Useful when
+     * higher-level logic (e.g. constrained regions) rolls back an illegal edit and does not want
+     * the rollback to echo back to the host.
+     */
+    withSuppressedChange: <T>(fn: () => T) => T;
+}
+export declare function useMonacoEditor(options: UseMonacoEditorOptions): UseMonacoEditorResult;
+//# sourceMappingURL=useMonacoEditor.d.ts.map

package/dist/composables/useMonacoEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMonacoEditor.d.ts","sourceRoot":"","sources":["../../src/composables/useMonacoEditor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAsC,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AACnE,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,UAAU,CAAC;AAmBlB,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,YAAY,GAAG,MAAM,CAAC;AAC5E,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAyD1D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAC9B,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,wBAAwB,CAAC;IACzC,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,KAAK,EAAE,MAAM,qBAAqB,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,uBAAuB,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;IAClD,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,qBAAqB,KAAK,IAAI,CAAC;CACvE;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC,CAAC;IAClE,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC;IACtD;;OAEG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;;;OAIG;IACH,oBAAoB,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;CAC7C;AAsDD,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,CAuPtF"}

package/dist/constrained/ChangeGuard.d.ts

@@ -0,0 +1,43 @@
+import { LockedLine, ProtectedRange } from './LockedLineScanner';
+import type * as monaco from 'monaco-editor';
+export type ChangeGuardRejectReason = 'edit-overlaps-locked-line';
+export interface ChangeGuardRejectEvent {
+    reason: ChangeGuardRejectReason;
+    /** 1-based line range of the rejected edit as reported by Monaco. */
+    range?: {
+        startLineNumber: number;
+        endLineNumber: number;
+    };
+}
+export interface ChangeGuardCallbacks {
+    onReject?: (event: ChangeGuardRejectEvent) => void;
+    onLinesUpdated?: (lines: readonly LockedLine[]) => void;
+    onContentChanged?: (value: string) => void;
+}
+/**
+ * Watches content changes on a Monaco model and rejects any edit that overlaps a locked
+ * line (including the line's trailing `\n`, so line-merging is blocked).
+ *
+ * Skipped automatically:
+ *  - `event.isFlush` — a full-document replacement via `setValue` from outside; trusted.
+ *  - `event.isUndoing` — the editor is replaying an undo (including our own rollback of an
+ *    illegal edit). We just refresh our cached scan; the undo itself is trusted.
+ *
+ * When `authoring()` returns true the guard becomes a passive observer — no rejects.
+ */
+export declare class ChangeGuard {
+    private readonly editor;
+    private readonly authoring;
+    private readonly callbacks;
+    private readonly disposables;
+    private lockedLines;
+    private protectedRanges;
+    constructor(editor: monaco.editor.IStandaloneCodeEditor, authoring: () => boolean, callbacks?: ChangeGuardCallbacks);
+    dispose(): void;
+    getLockedLines(): readonly LockedLine[];
+    getProtectedRanges(): readonly ProtectedRange[];
+    /** Re-scan the model after an external change that bypassed onDidChangeContent. */
+    refresh(): void;
+    private handleChange;
+}
+//# sourceMappingURL=ChangeGuard.d.ts.map

package/dist/constrained/ChangeGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChangeGuard.d.ts","sourceRoot":"","sources":["../../src/constrained/ChangeGuard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,uBAAuB,GAAG,2BAA2B,CAAC;AAElE,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,uBAAuB,CAAC;IAChC,qEAAqE;IACrE,KAAK,CAAC,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;IACnD,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,KAAK,IAAI,CAAC;IACxD,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAED;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IAMpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAP5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,eAAe,CAAmB;gBAGvB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAC3C,SAAS,EAAE,MAAM,OAAO,EACxB,SAAS,GAAE,oBAAyB;IAWvD,OAAO,IAAI,IAAI;IAIf,cAAc,IAAI,SAAS,UAAU,EAAE;IAIvC,kBAAkB,IAAI,SAAS,cAAc,EAAE;IAI/C,mFAAmF;IACnF,OAAO,IAAI,IAAI;IAQf,OAAO,CAAC,YAAY;CAwCrB"}

package/dist/constrained/CursorGuard.d.ts

@@ -0,0 +1,21 @@
+import { ProtectedRange } from './LockedLineScanner';
+import type * as monaco from 'monaco-editor';
+/**
+ * Keeps cursors out of the interior of locked lines. When enforcement is on and a cursor
+ * endpoint lands strictly inside a protected range, it is snapped to the closer boundary.
+ *
+ * Reads protected ranges from a getter so the guard always uses the latest scan — ranges
+ * shift whenever content above a locked line changes.
+ */
+export declare class CursorGuard {
+    private readonly editor;
+    private readonly getRanges;
+    private readonly authoring;
+    private readonly disposables;
+    private correcting;
+    constructor(editor: monaco.editor.IStandaloneCodeEditor, getRanges: () => readonly ProtectedRange[], authoring: () => boolean);
+    dispose(): void;
+    snapCurrent(): void;
+    private handleSelectionChange;
+}
+//# sourceMappingURL=CursorGuard.d.ts.map

package/dist/constrained/CursorGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorGuard.d.ts","sourceRoot":"","sources":["../../src/constrained/CursorGuard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEpF;;;;;;GAMG;AACH,qBAAa,WAAW;IAKpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,OAAO,CAAC,UAAU,CAAS;gBAGR,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAC3C,SAAS,EAAE,MAAM,SAAS,cAAc,EAAE,EAC1C,SAAS,EAAE,MAAM,OAAO;IAO3C,OAAO,IAAI,IAAI;IAIf,WAAW,IAAI,IAAI;IAInB,OAAO,CAAC,qBAAqB;CA6C9B"}

package/dist/constrained/DiagnosticsFilter.d.ts

@@ -0,0 +1,29 @@
+import * as monaco from 'monaco-editor';
+/**
+ * Suppresses error-severity TypeScript markers that fall on locked lines.
+ *
+ * Why: when a user types an incomplete body (e.g. an unbalanced `}`), the TS parser's
+ * recovery often flags the surrounding *signature* as a syntax error. For the user that
+ * signature appears broken, even though they never touched it — and can't fix it anyway.
+ * We hide those errors until the body stabilises.
+ *
+ * Scope:
+ *  - Only the editor's own model is filtered.
+ *  - Only severity `Error` markers; warnings and info are left alone.
+ *  - When `authoring()` returns true (template authoring), the filter stands down — the
+ *    author needs to see every diagnostic.
+ */
+export declare class DiagnosticsFilter {
+    private readonly editor;
+    private readonly authoring;
+    private readonly disposables;
+    /** Re-entrancy guard: our own `setModelMarkers` fires `onDidChangeMarkers` again. */
+    private filtering;
+    constructor(editor: monaco.editor.IStandaloneCodeEditor, authoring: () => boolean);
+    dispose(): void;
+    /** Force a re-scan + re-filter — useful after the markers set changes externally. */
+    refresh(): void;
+    private handleMarkerChange;
+    private filterMarkers;
+}
+//# sourceMappingURL=DiagnosticsFilter.d.ts.map

package/dist/constrained/DiagnosticsFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiagnosticsFilter.d.ts","sourceRoot":"","sources":["../../src/constrained/DiagnosticsFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,qFAAqF;IACrF,OAAO,CAAC,SAAS,CAAS;gBAGP,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAC3C,SAAS,EAAE,MAAM,OAAO;IAS3C,OAAO,IAAI,IAAI;IAIf,qFAAqF;IACrF,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,aAAa;CAoDtB"}

package/dist/constrained/LockedLineScanner.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Line-based locking.
+ *
+ * Any line containing `// @locked` (optionally followed by more text) is protected:
+ * the user cannot edit, merge, or delete that line. The marker is an ordinary line
+ * comment, so the locked source is a valid `.ts`/`.js` file in any toolchain.
+ *
+ *   function describeOrder(order: Order): string { // @locked
+ *     return 'hi';
+ *   } // @locked
+ *
+ * Matches are case-sensitive and require a word boundary after `locked` so lines like
+ * `// @lockedx` do not trigger.
+ */
+export declare const LOCKED_MARKER_TEXT = "// @locked";
+export interface LockedLine {
+    /** 0-based line index within the source. */
+    lineIndex: number;
+    /** First offset of the line (character immediately after the previous `\n`, or 0). */
+    lineStart: number;
+    /**
+     * Offset of the `\n` terminating the line, or `source.length` for the last line with no
+     * trailing newline. This is an **inclusive** upper bound on the protected range — inserts
+     * and deletes that touch this offset belong to the locked line.
+     */
+    lineEnd: number;
+    /**
+     * Start offset of the protected range. Equals `lineStart` — an insertion at this offset
+     * extends the locked line's content, so it is protected.
+     */
+    protectedStart: number;
+    /**
+     * End offset of the protected range, **inclusive**. Equals `lineEnd`. An insertion at
+     * this offset extends the locked line's content (before the `\n`), a deletion of this
+     * offset removes the `\n` and merges the next line in — both protected.
+     */
+    protectedEnd: number;
+    /** Valid snap target before the locked line (end of the previous line), or null if this is the first line. */
+    snapBefore: number | null;
+    /** Valid snap target after the locked line (start of the next line), or null if this is the last line with no trailing `\n`. */
+    snapAfter: number | null;
+}
+/** Contiguous protected range, produced by merging adjacent locked lines. */
+export interface ProtectedRange {
+    start: number;
+    end: number;
+    /** Valid snap target before the block, or null if the block starts at file begin. */
+    snapBefore: number | null;
+    /** Valid snap target after the block, or null if the block ends at file end with no trailing `\n`. */
+    snapAfter: number | null;
+}
+export declare function hasLockedMarkers(source: string): boolean;
+export declare function scanLockedLines(source: string): LockedLine[];
+/**
+ * Merge adjacent locked lines into contiguous blocks. Two locks are adjacent when the next
+ * one begins exactly one character after the previous one ends (the `\n` between them). The
+ * resulting `ProtectedRange`s propagate the outermost `snapBefore` / `snapAfter`.
+ */
+export declare function computeProtectedRanges(lines: readonly LockedLine[]): ProtectedRange[];
+/**
+ * Inclusive overlap test: does an edit `[rangeStart, rangeEnd]` touch the protected range
+ * `[range.start, range.end]`? Uses inclusive bounds on both sides — an insertion exactly at
+ * `range.start` or `range.end` counts as overlap, because both positions would extend the
+ * locked line's content.
+ */
+export declare function overlapsProtectedRange(edit: {
+    rangeStart: number;
+    rangeEnd: number;
+}, range: ProtectedRange): boolean;
+export declare function editIsProtected(edit: {
+    rangeStart: number;
+    rangeEnd: number;
+}, ranges: readonly ProtectedRange[]): boolean;
+/**
+ * Snap an offset away from protected territory. If the offset lies inside any protected
+ * range (inclusive), snap to the nearer valid free position. For first-line locks the only
+ * valid target is `snapAfter`; for last-line locks without a trailing `\n`, only `snapBefore`
+ * is valid. Returns `0` as ultimate fallback if neither side is valid (fully-locked file).
+ */
+export declare function snapOffsetAwayFromLocked(offset: number, ranges: readonly ProtectedRange[]): number;
+/** Number of lines that carry a `// @locked` marker. */
+export declare function countLockedLines(source: string): number;
+/**
+ * Common submit-gate check: true when every editable segment contains at least one
+ * non-whitespace character. "Every body has been filled in."
+ */
+export declare function isEverySegmentNonEmpty(source: string): boolean;
+export interface SourceValidation {
+    /** Always present — the scanner never throws. Indicates whether any warnings surfaced. */
+    ok: boolean;
+    lockedLineCount: number;
+    segmentCount: number;
+    /**
+     * Informational warnings the consumer may want to surface. Examples:
+     * "source starts with a locked line — imports cannot be added above it".
+     */
+    warnings: string[];
+}
+/**
+ * Quick structural check for a template or persisted source. Non-throwing; use it when you
+ * want to surface soft warnings (e.g. during template authoring) without refusing to mount.
+ */
+export declare function validateSource(source: string): SourceValidation;
+/**
+ * Returns the text of each *editable* block — the stretches of consecutive non-locked
+ * lines. If the source has no locked lines, returns a single-element array with the full
+ * source. Useful for validation like "every block contains at least one non-empty line".
+ */
+export declare function getEditableSegments(source: string): string[];
+//# sourceMappingURL=LockedLineScanner.d.ts.map

package/dist/constrained/LockedLineScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockedLineScanner.d.ts","sourceRoot":"","sources":["../../src/constrained/LockedLineScanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAE/C,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,8GAA8G;IAC9G,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,gIAAgI;IAChI,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,6EAA6E;AAC7E,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,qFAAqF;IACrF,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,sGAAsG;IACtG,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,EAAE,CA8B5D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,cAAc,EAAE,CA6BrF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC9C,KAAK,EAAE,cAAc,GACpB,OAAO,CAET;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC9C,MAAM,EAAE,SAAS,cAAc,EAAE,GAChC,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,cAAc,EAAE,GAChC,MAAM,CAYR;AAED,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,MAAM,WAAW,gBAAgB;IAC/B,0FAA0F;IAC1F,EAAE,EAAE,OAAO,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAoB/D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAuB5D"}

package/dist/index.css

@@ -0,0 +1,2 @@
+.coar-script-editor{border:1px solid var(--coar-border-input,var(--coar-border-neutral-tertiary,#e5e7eb));border-radius:var(--coar-radius-xs,4px);background:var(--coar-background-neutral-primary,#fff);width:100%;height:100%;min-height:200px;transition:border-color var(--coar-duration-fast,.15s) var(--coar-ease-out,ease-out), box-shadow var(--coar-duration-fast,.15s) var(--coar-ease-out,ease-out);--coar-script-editor-marker-scale:.6;--coar-script-editor-marker-opacity:.45;--coar-script-editor-marker-color:var(--coar-text-neutral-tertiary,#6b7280);--coar-script-editor-locked-line-bg:color-mix(in srgb, var(--coar-text-neutral-tertiary,#6b7280) 6%, transparent);display:block;position:relative;overflow:hidden}.coar-script-editor--inline{min-height:0}.coar-script-editor--inline:not(.coar-script-editor--disabled):hover{border-color:var(--coar-border-input-hover,#9ca3af)}.coar-script-editor--inline:focus-within:not(.coar-script-editor--error){border-color:var(--coar-focus-color,#3b82f6);box-shadow:inset 0 0 0 1px var(--coar-focus-color,#3b82f6)}.coar-script-editor--error{border-color:var(--coar-border-semantic-error-bold,#dc2626)}.coar-script-editor--error:focus-within{border-color:var(--coar-border-semantic-error-bold,#dc2626);box-shadow:inset 0 0 0 1px var(--coar-border-semantic-error-bold,#dc2626)}.coar-script-editor--disabled{opacity:.6;cursor:not-allowed;pointer-events:none;background:var(--coar-surface-input-disabled,#f3f4f6)}.coar-script-editor--show-placeholder:after{content:attr(data-placeholder);color:var(--coar-text-placeholder,#9ca3af);pointer-events:none;white-space:pre-line;z-index:1;font-family:Fira Code,Cascadia Code,Consolas,monospace;font-size:13px;position:absolute;top:8px;left:12px}.coar-script-editor:not(.coar-script-editor--inline).coar-script-editor--show-placeholder:after{left:68px}.coar-script-editor--authoring{--coar-script-editor-marker-scale:1;--coar-script-editor-marker-opacity:.85;--coar-script-editor-marker-color:var(--coar-text-warning,#b45309);--coar-script-editor-locked-line-bg:color-mix(in srgb, var(--coar-text-warning,#b45309) 10%, transparent)}.coar-script-editor-locked-line{background:var(--coar-script-editor-locked-line-bg)}.coar-script-editor-locked-marker{font-size:calc(1em * var(--coar-script-editor-marker-scale));opacity:var(--coar-script-editor-marker-opacity);letter-spacing:-.02em;color:var(--coar-script-editor-marker-color)}
+/*$vite$:1*/

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { default as CoarScriptEditor } from './CoarScriptEditor.vue';
+export type { CoarScriptEditorProps, CoarScriptEditorRejectReason, CoarScriptEditorRejectEvent, } from './CoarScriptEditor.vue';
+export type { CoarScriptEditorLanguage, CoarScriptEditorVariant, } from './composables/useMonacoEditor';
+export type { CoarScriptEditorExtraLib } from './composables/useExtraLibs';
+export type { CoarScriptEditorTheme } from './theme';
+export { COAR_THEME_LIGHT, COAR_THEME_DARK, ensureCoarThemes, detectAutoTheme, watchAutoTheme, } from './theme';
+export { scanLockedLines, computeProtectedRanges, hasLockedMarkers, getEditableSegments, overlapsProtectedRange, editIsProtected, snapOffsetAwayFromLocked, countLockedLines, isEverySegmentNonEmpty, validateSource, LOCKED_MARKER_TEXT, type LockedLine, type ProtectedRange, type SourceValidation, } from './constrained/LockedLineScanner';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACrE,YAAY,EACV,qBAAqB,EACrB,4BAA4B,EAC5B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC3E,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,cAAc,GACf,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC"}