svedit 0.11.1 → 0.12.0

package/dist/Command.svelte.js

@@ -1,5 +1,5 @@
 import { insert_default_node, break_text_node } from './transforms.svelte.js';
-import { can_switch_annotation_type } from './doc_utils.js';
+import { can_switch_mark_type, get_selected_range_types } from './doc_utils.js';
 import { is_selection_collapsed, get_char_length, char_slice } from './utils.js';
 
 /**
@@ -107,10 +107,13 @@ export class SelectParentCommand extends Command {
 }
 
 /**
- * Generic command that toggles an annotation on the current text selection.
- * Used for simple annotations like bold, italic, highlight, etc.
+ * Generic command that toggles a mark on the current text or node selection.
+ *
+ * Marks are mutually exclusive, so all touched marks compete: same-type marks
+ * are removed, a single touched property-less mark may switch type, and mixed
+ * touched types disable the command. Annotations never affect mark toggling.
  */
-export class ToggleAnnotationCommand extends Command {
+export class ToggleMarkCommand extends Command {
 	constructor(node_type, context) {
 		super(context);
 		this.node_type = node_type;
@@ -119,34 +122,89 @@ export class ToggleAnnotationCommand extends Command {
 	active = $derived(this.is_active());
 
 	is_active() {
-		return this.context.session.active_annotation(this.node_type);
+		const selected_marks = this.context.session.selected_marks;
+		return (
+			selected_marks.length > 0 &&
+			selected_marks.every(({ node }) => node?.type === this.node_type)
+		);
 	}
 
 	is_enabled() {
 		const { session, editable } = this.context;
-		const active_annotation = session.active_annotation();
-		const has_annotation = session.active_annotation(this.node_type);
-		const can_switch_annotation =
-			active_annotation &&
-			!has_annotation &&
-			session.available_annotation_types.includes(this.node_type) &&
-			can_switch_annotation_type(
-				session.schema,
-				session.get(active_annotation.node_id),
-				this.node_type
-			);
-		const no_annotation_and_caret_not_collapsed =
-			!active_annotation && !is_selection_collapsed(session.selection);
+		const selection = session.selection;
+		const is_valid_selection =
+			selection?.type === 'text' ||
+			(selection?.type === 'node' && !is_selection_collapsed(selection));
+		const mark_type_is_allowed = session.available_mark_types.includes(this.node_type);
+		const selected_marks = session.selected_marks;
+		const selected_mark_types = get_selected_range_types(selected_marks);
+
+		if (!editable || !is_valid_selection || !mark_type_is_allowed) return false;
+		if (selected_mark_types.size > 1) return false;
+
+		if (selected_marks.length === 0) {
+			return Boolean(selection && !is_selection_collapsed(selection));
+		}
 
-		return (
-			editable &&
-			session.selection?.type === 'text' &&
-			(has_annotation || can_switch_annotation || no_annotation_and_caret_not_collapsed)
+		const first_selected_mark = selected_marks[0];
+		const selected_mark_type = first_selected_mark.node.type;
+		if (selected_mark_type === this.node_type) return true;
+		if (selected_marks.length !== 1) return false;
+
+		return can_switch_mark_type(session.schema, selected_mark_type, this.node_type);
+	}
+
+	execute() {
+		this.context.session.apply(this.context.session.tr.toggle_mark(this.node_type));
+	}
+}
+
+/**
+ * Generic command that toggles an annotation on the current text or node selection.
+ *
+ * Annotations only compete with touched annotations of the same type: touched
+ * same-type annotations are removed, otherwise a new annotation is created.
+ * Marks and other annotation types never block the toggle.
+ */
+export class ToggleAnnotationCommand extends Command {
+	constructor(node_type, context) {
+		super(context);
+		this.node_type = node_type;
+	}
+
+	active = $derived(this.is_active());
+
+	// Mirrors the filter in tr.toggle_annotation, so active/enabled match what
+	// execute() does.
+	relevant_annotations() {
+		return this.context.session.selected_annotations.filter(
+			({ node }) => node?.type === this.node_type
 		);
 	}
 
+	is_active() {
+		return this.relevant_annotations().length > 0;
+	}
+
+	is_enabled() {
+		const { session, editable } = this.context;
+		const selection = session.selection;
+		const is_valid_selection =
+			selection?.type === 'text' ||
+			(selection?.type === 'node' && !is_selection_collapsed(selection));
+		const annotation_type_is_allowed = session.available_annotation_types.includes(this.node_type);
+
+		if (!editable || !is_valid_selection || !annotation_type_is_allowed) return false;
+
+		// Removing touched same-type annotations also works from a collapsed
+		// caret inside the annotation; creating a new one requires an expanded
+		// selection.
+		if (this.relevant_annotations().length > 0) return true;
+		return Boolean(selection && !is_selection_collapsed(selection));
+	}
+
 	execute() {
-		this.context.session.apply(this.context.session.tr.annotate_text(this.node_type));
+		this.context.session.apply(this.context.session.tr.toggle_annotation(this.node_type));
 	}
 }
 
@@ -179,7 +237,7 @@ export class AddNewLineCommand extends Command {
 
 		const collapsed_offset = tr.selection.anchor_offset;
 		const content = tr.get(tr.selection.path);
-		const text_before_caret = char_slice(content.text, 0, collapsed_offset);
+		const text_before_caret = char_slice(content.content, 0, collapsed_offset);
 		const line_start_index = text_before_caret.lastIndexOf('\n') + 1;
 		const current_line_prefix = text_before_caret.slice(line_start_index);
 		const indentation_match = current_line_prefix.match(/^[\t ]*/);
@@ -235,7 +293,7 @@ export class SelectAllCommand extends Command {
 
 		if (selection.type === 'text') {
 			const text_content = session.get(selection.path);
-			const text_length = get_char_length(text_content.text);
+			const text_length = get_char_length(text_content.content);
 
 			// Check if all text is already selected
 			const is_all_text_selected =
@@ -278,7 +336,7 @@ export class SelectAllCommand extends Command {
 			// Check if the entire node_array is already selected
 			const is_entire_node_array_selected =
 				Math.min(selection.anchor_offset, selection.focus_offset) === 0 &&
-				Math.max(selection.anchor_offset, selection.focus_offset) === node_array.length;
+				Math.max(selection.anchor_offset, selection.focus_offset) === node_array.nodes.length;
 
 			if (!is_entire_node_array_selected) {
 				// Select the entire node_array
@@ -286,7 +344,7 @@ export class SelectAllCommand extends Command {
 					type: 'node',
 					path: node_array_path,
 					anchor_offset: 0,
-					focus_offset: node_array.length
+					focus_offset: node_array.nodes.length
 				};
 			} else {
 				// Entire node_array is selected, try to move up to parent node_array

package/dist/Node.svelte

@@ -16,17 +16,45 @@
 	let child_index = $derived(node_array_meta ? parseInt(String(path.at(-1)), 10) : -1);
 	let is_first = $derived(node_array_meta && child_index === 0);
 	let is_last = $derived(node_array_meta && child_index === node_array_meta.length - 1);
+
+	// Marks and annotations covering this node become classes automatically:
+	// `mark-<type>`/`anno-<type>`, plus `-start`/`-end` variants on the run's
+	// first/last covered node. This allows styling ranges (including
+	// annotations, which never render wrapper components) with pure CSS. For
+	// richer rendering, node components still receive the `mark` and
+	// `annotations` props.
+	let range_classes = $derived.by(() => {
+		if (child_index < 0 || !node_array_meta?.annotations_for) return '';
+		const classes = [];
+
+		const add_classes = (range, prefix) => {
+			const range_type = range?.node?.type;
+			if (!range_type) return;
+			classes.push(`${prefix}-${range_type}`);
+			if (range.is_start) classes.push(`${prefix}-${range_type}-start`);
+			if (range.is_end) classes.push(`${prefix}-${range_type}-end`);
+		};
+
+		add_classes(node_array_meta.mark_for?.(child_index), 'mark');
+		for (const annotation of node_array_meta.annotations_for(child_index)) {
+			add_classes(annotation, 'anno');
+		}
+		return classes.join(' ');
+	});
 </script>
 
 <svelte:element
 	this={tag}
 	id={node.id}
-	class="node-{node.type} {css_class}{is_first ? ' first' : ''}{is_last ? ' last' : ''}"
+	class="node-{node.type} {css_class}{range_classes
+		? ` ${range_classes}`
+		: ''}{is_first ? ' first' : ''}{is_last ? ' last' : ''}"
 	data-node-id={node.id}
 	data-path={path_str}
 	data-type="node"
 	style="anchor-name: --{path_str};{style}"
 	{...rest}
+	{@attach svedit.visibility_registry.track_node(path_str)}
 >
 	{@render children()}
 </svelte:element>

package/dist/Node.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Node.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Node.svelte.js"],"names":[],"mappings":";;;;;AAkCA,yFAAmD"}
+{"version":3,"file":"Node.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Node.svelte.js"],"names":[],"mappings":";;;;;AA6DA,yFAAmD"}

package/dist/NodeArrayProperty.svelte

@@ -1,11 +1,11 @@
 <script>
 	import { getContext, setContext } from 'svelte';
 	import UnknownNode from './UnknownNode.svelte';
-	import { serialize_path } from './utils.js';
+	import { serialize_path, calculate_fragment_ranges } from './utils.js';
 	import DefaultNodeGap from './NodeGap.svelte';
 	import DefaultNodeGapMarkers from './NodeGapMarkers.svelte';
 
-	/** @import { NodeArrayPropertyProps } from './types.d.ts'; */
+	/** @import { NodeArrayPropertyProps, NodeArrayAttachmentContext } from './types.d.ts'; */
 
 	const svedit = getContext('svedit');
 	let NodeGap = $derived(svedit.session.config.system_components?.node_gap ?? DefaultNodeGap);
@@ -20,10 +20,85 @@
 	// NodeGap's should_position_gap call to avoid N+1 joins per render.
 	let path_str = $derived(serialize_path(path));
 
-	let node_ids = $derived(svedit.session.get(path));
-	let nodes = $derived(node_ids.map((id) => svedit.session.get(id)));
+	let raw_value = $derived(svedit.session.get(path));
+	let node_ids = $derived(raw_value.nodes);
+	let marks = $derived(raw_value.marks);
+	let annotations = $derived(raw_value.annotations);
 
-	// Mirrors the AnnotatedTextProperty pattern: a `focused` class follows
+	let fragments = $derived(get_fragments(node_ids, marks));
+
+	function get_fragments(node_ids, marks) {
+		const ranges = calculate_fragment_ranges(node_ids.length, marks);
+		let fragments = [];
+
+		for (const range of ranges) {
+			const nodes_slice = node_ids.slice(range.start_offset, range.end_offset);
+
+			if (range.type === 'mark') {
+				const node = svedit.session.get(range.node_id);
+				fragments.push({
+					type: 'mark',
+					node,
+					nodes: nodes_slice,
+					start_index: range.start_offset,
+					mark_index: range.mark_index
+				});
+			} else if (range.type === 'content') {
+				fragments.push({
+					type: 'nodes',
+					nodes: nodes_slice,
+					start_index: range.start_offset
+				});
+			}
+		}
+		return fragments;
+	}
+
+	function get_node_key(node_id, index) {
+		let occurrence = 0;
+		for (let current_index = 0; current_index < index; current_index++) {
+			if (node_ids[current_index] === node_id) occurrence += 1;
+		}
+		return `${node_id}:${occurrence}`;
+	}
+
+	/**
+	 * @returns {NodeArrayAttachmentContext}
+	 */
+	function get_range_context(range, index, node_index) {
+		const node = svedit.session.get(range.node_id);
+		const is_start = node_index === range.start_offset;
+		const is_end = node_index === range.end_offset - 1;
+
+		return {
+			...range,
+			index,
+			node,
+			is_start,
+			is_middle: !is_start && !is_end,
+			is_end
+		};
+	}
+
+	function get_covering_ranges(ranges, node_index) {
+		return ranges
+			.map((range, index) => ({ range, index }))
+			.filter(({ range }) => range.start_offset <= node_index && node_index < range.end_offset)
+			.map(({ range, index }) => get_range_context(range, index, node_index));
+	}
+
+	function get_annotation_contexts(node_index) {
+		return get_covering_ranges(annotations, node_index);
+	}
+
+	function get_mark(node_index) {
+		// The single mark wrapping this node, or null. Mark exclusivity
+		// guarantees at most one. Annotations never wrap and are exposed via
+		// `annotations` instead.
+		return get_covering_ranges(marks, node_index)[0] ?? null;
+	}
+
+	// Mirrors the TextProperty pattern: a `focused` class follows
 	// the model selection. Used by the CSS rule below to hide the empty-array
 	// NodeGap while the caret is in the placeholder, so its <br> isn't a
 	// second arrow-key stop (issue #260).
@@ -35,6 +110,15 @@
 	setContext('node_array_meta', {
 		get length() {
 			return node_ids.length;
+		},
+		// Lets Node self-serve the marks and annotations covering a child, so
+		// node wrappers can carry range classes without every node component
+		// having to thread the `mark`/`annotations` props through.
+		mark_for(node_index) {
+			return get_mark(node_index);
+		},
+		annotations_for(node_index) {
+			return get_annotation_contexts(node_index);
 		}
 	});
 </script>
@@ -48,6 +132,7 @@
 	data-path={path_str}
 	style="anchor-name: --{path_str};{style ? ` ${style}` : ''}"
 	{...rest}
+	{@attach svedit.visibility_registry.track_array(path_str)}
 >
 	{#if node_ids.length === 0 && svedit.editable}
 		<div
@@ -55,17 +140,39 @@
 			data-path={serialize_path([...path, 0])}
 			data-type="node"
 			style="anchor-name: --{serialize_path([...path, 0])};"
+			{@attach svedit.visibility_registry.track_node(serialize_path([...path, 0]))}
 		>
 			<NodeGap array_path={path} offset={0} count={0} empty />
 		</div>
 	{/if}
-	{#each nodes as node, index (index)}
-		<NodeGap array_path={path} offset={index} count={nodes.length} />
-		{@const Component = svedit.session.config.node_components[node.type]}
-		{#if Component}
-			<Component path={[...path, index]} />
-		{:else}
-			<UnknownNode path={[...path, index]} />
+	{#snippet render_nodes(nodes_slice, start_index)}
+		{#each nodes_slice as id, slice_index (get_node_key(id, start_index + slice_index))}
+			{@const index = start_index + slice_index}
+			{@const node = svedit.session.get(id)}
+			{@const mark = get_mark(index)}
+			{@const annotations = get_annotation_contexts(index)}
+			<NodeGap array_path={path} offset={index} count={node_ids.length} />
+			{@const Component = svedit.session.config.node_components[node.type]}
+			{#if Component}
+				<Component path={[...path, index]} {mark} {annotations} />
+			{:else}
+				<UnknownNode path={[...path, index]} />
+			{/if}
+		{/each}
+	{/snippet}
+
+	{#each fragments as fragment, fragment_index (fragment_index)}
+		{#if fragment.type === 'nodes'}
+			{@render render_nodes(fragment.nodes, fragment.start_index)}
+		{:else if fragment.type === 'mark'}
+			{@const MarkComponent = svedit.session.config.node_components[fragment.node.type]}
+			{#if MarkComponent}
+				<MarkComponent path={[...path, 'marks', fragment.mark_index, 'node_id']}>
+					{@render render_nodes(fragment.nodes, fragment.start_index)}
+				</MarkComponent>
+			{:else}
+				{@render render_nodes(fragment.nodes, fragment.start_index)}
+			{/if}
 		{/if}
 	{/each}
 	{#if node_ids.length > 0}

package/dist/NodeArrayProperty.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeArrayProperty.svelte.d.ts","sourceRoot":"","sources":["../src/lib/NodeArrayProperty.svelte.js"],"names":[],"mappings":";;;;;AA8EA,mHAAgE"}
+{"version":3,"file":"NodeArrayProperty.svelte.d.ts","sourceRoot":"","sources":["../src/lib/NodeArrayProperty.svelte.js"],"names":[],"mappings":";;;;;AAuLA,mHAAgE"}

package/dist/NodeGap.svelte

@@ -13,6 +13,7 @@
 <script>
 	import { serialize_path } from './utils.js';
 	import { getContext } from 'svelte';
+	import { should_position_gap } from './node_visibility.svelte.js';
 
 	/**
 	 * ┌─────────────────────────────────────────────────────────────────┐
@@ -37,10 +38,13 @@
 	 *
 	 * Always present in the DOM when editable (stable structure for
 	 * selection anchoring, scrollTo, etc.). Anchor positioning is
-	 * activated lazily via the `.positioned` class, toggled imperatively
-	 * by the IO callback / MO / bootstrap in node_visibility — keeps
-	 * NodeGap allocation-free of per-instance Svelte signals, which
-	 * matters at 1000+ NodeGaps per scroll frame.
+	 * activated lazily via the `.positioned` class, derived reactively
+	 * from the visibility registry's array_indices / edge_map. Svelte's
+	 * reactive collections track reads at per-key granularity, so a
+	 * registry write only
+	 * re-evaluates the adjacent gaps. Applying the class declaratively
+	 * (instead of imperative classList toggles) means it survives DOM
+	 * recreation without a document change (e.g. dev-mode HMR).
 	 *
 	 * `position-visibility: anchors-visible` does NOT skip anchor
 	 * resolution — the browser resolves all anchor() then hides the
@@ -62,6 +66,22 @@
 	let is_last = $derived(offset === count);
 	let type = $derived(is_first ? 'gap-before' : 'gap-after');
 
+	let path_str = $derived(serialize_path(array_path));
+	// Two-derived split is load-bearing: get_array_indices lazily
+	// creates the set, and Svelte doesn't track deps on state created
+	// inside the reading derived — so acquire here, read in `positioned`.
+	let near_indices = $derived(svedit.visibility_registry.get_array_indices(path_str));
+	let positioned = $derived(
+		is_editable &&
+			should_position_gap(
+				near_indices,
+				svedit.visibility_registry.edge_map.get(path_str),
+				offset,
+				is_last,
+				empty
+			)
+	);
+
 	let gap_style = $derived.by(() => {
 		if (!is_editable) return '';
 		const prev_idx = offset - 1;
@@ -87,8 +107,9 @@
 		class:gap-after={!is_first}
 		class:empty
 		class:last={is_last}
+		class:positioned
 		data-type={type}
-		data-gap-array-path={serialize_path(array_path)}
+		data-gap-array-path={path_str}
 		data-gap-offset={offset}
 		style={gap_style}
 	>
@@ -111,9 +132,30 @@
 	}
 
 	/* ------------------------------------------------------------------ */
-	/* Un-positioned: minimal in-DOM presence, no anchor resolution        */
+	/* Un-positioned: no layout box at all                                 */
 	/* ------------------------------------------------------------------ */
 
+	/*
+	 * display: none is load-bearing for large documents. A zero-size
+	 * absolutely-positioned selectable still belongs to the containing
+	 * block's out-of-flow list, and the browser lays out EVERY such box
+	 * on EVERY layout pass — measured ~430ms per pass at 2000 nodes
+	 * (~3500 gaps) in Chrome vs ~23ms with the boxes removed. That cost
+	 * hits every keystroke (the per-change reconcile reads a rect for
+	 * every node, and selection rendering forces layout), every window
+	 * resize frame, and every scroll-triggered layout.
+	 *
+	 * Off-screen gaps therefore contribute no layout box. DOM structure
+	 * stays stable (the .node-gap wrapper and selectable elements remain),
+	 * and DOM Ranges may still point into display:none elements, so
+	 * programmatic node selections targeting off-screen gaps keep working.
+	 * Empty-array gaps are excluded: they must stay clickable/visible even
+	 * before reconcile positions them.
+	 */
+	:global(.node-gap:not(.positioned):not(.empty) .svedit-selectable) {
+		display: none;
+	}
+
 	:global(.node-gap:not(.positioned) .svedit-selectable) {
 		position: absolute;
 		pointer-events: none;

package/dist/NodeGap.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeGap.svelte.d.ts","sourceRoot":"","sources":["../src/lib/NodeGap.svelte.js"],"names":[],"mappings":";;;;;AAwGA;gBA1CgC,GAAG;YAAU,GAAG;WAAS,GAAG;YAAU,OAAO;WA0CvB;wBA1CpC;IAAE,UAAU,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE"}
+{"version":3,"file":"NodeGap.svelte.d.ts","sourceRoot":"","sources":["../src/lib/NodeGap.svelte.js"],"names":[],"mappings":";;;;;AA6HA;gBA1DgC,GAAG;YAAU,GAAG;WAAS,GAAG;YAAU,OAAO;WA0DvB;wBA1DpC;IAAE,UAAU,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE"}

package/dist/Session.svelte.d.ts

@@ -27,7 +27,24 @@ export default class Session {
     can_undo: boolean;
     can_redo: boolean;
     selected_node: any;
+    available_mark_types: any;
     available_annotation_types: any;
+    selected_marks: (Attachment & {
+        index: number;
+        node: any;
+    })[];
+    active_mark: Attachment & {
+        index: number;
+        node: any;
+    };
+    selected_annotations: (Attachment & {
+        index: number;
+        node: any;
+    })[];
+    active_annotation: Attachment & {
+        index: number;
+        node: any;
+    };
     /**
      * Sets the selection with validation
      * @param {Selection | null} value - The new selection
@@ -76,6 +93,7 @@ export default class Session {
      * @param {object} context - The svedit context with session, editable, canvas, etc.
      */
     initialize_commands(context: object): void;
+    get_available_mark_types(): any;
     get_available_annotation_types(): any;
     get_selected_node(): any;
     /**
@@ -114,8 +132,8 @@ export default class Session {
      * session.get(['page_1', 'body', 3, 'list_items', 0]) // => { type: 'list_item', id: 'list_item_1', ... }
      *
      * @example
-     * // Get an annotated text property
-     * session.get(['page_1', 'cover', 'title']) // => {text: 'Hello world', annotations: []}
+     * // Get a text property
+     * session.get(['page_1', 'cover', 'title']) // => {content: 'Hello world', marks: [], annotations: []}
      */
     get(path: DocumentPath | string): any;
     /**
@@ -150,7 +168,7 @@ export default class Session {
     };
     /**
      * Determines the kind of a node ('block' for structured blocks, 'text' for pure
-     * text nodes or 'annotation' for annotation nodes.
+     * text nodes, 'mark' for mark nodes or 'annotation' for annotation nodes.
      * @param {any} node
      * @returns {NodeKind}
      */
@@ -169,19 +187,18 @@ export default class Session {
      * @returns {Selection|null} The next node insert caret selection, or null if none is available
      */
     get_next_node_insert_caret(selection?: Selection): Selection | null;
-    /**
-     * Returns the annotation object that is currently "under the cursor".
-     * NOTE: Annotations in Svedit are exclusive, so there can only be one active_annotation
-     *
-     * @param {string} [annotation_type] Optional annotation type to filter by
-     * @returns {Annotation|null}
-     */
-    active_annotation(annotation_type?: string): Annotation | null;
-    get_selected_annotated_text(): {
-        text: string;
+    get_selected_text(): {
+        content: string;
+        marks: any;
         annotations: any;
         nodes: {};
     };
+    get_selected_annotated_nodes(): {
+        nodes: {};
+        main_nodes: any;
+        marks: any;
+        annotations: any;
+    };
     get_selected_plain_text(): string;
     get_selected_nodes(): any;
     select_parent(): void;
@@ -224,11 +241,11 @@ export type SessionOptions = {
 };
 import type { DocumentSchema } from './types.d.ts';
 import type { Document } from './types.d.ts';
+import type { Attachment } from './types.d.ts';
 import type { Selection } from './types.d.ts';
 import Transaction from './Transaction.svelte.js';
 import type { DocumentPath } from './types.d.ts';
 import type { NodeKind } from './types.d.ts';
-import type { Annotation } from './types.d.ts';
 import type { DocumentNode } from './types.d.ts';
 import type { NodeId } from './types.d.ts';
 //# sourceMappingURL=Session.svelte.d.ts.map

package/dist/Session.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Session.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Session.svelte.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;IA+BC;;;;;;OAMG;IACH,oBANW,cAAc,OACd,QAAQ,UACR,MAAM,YAEd;QAA4B,SAAS,GAA7B,SAAS;KACnB,EAYA;IA7CD,6BAA6B;IAC7B,QADW,cAAc,CACH;IAEtB,uBAAuB;IACvB,KADW,QAAQ,CACA;IAEnB,kBAAkB;IAClB,QADW,GAAG,CACQ;IAEtB,eAAyB;IACzB,sBAA+B;IAC/B,wBAA2C;IAI3C,aAA0B;IAC1B,WAAwB;IAGxB,kBAA6C;IAC7C,kBAAkE;IAGlE,mBAAmD;IACnD,gCAA6E;IA+B7E;;;;OAIG;IACH,qBAHW,SAAS,GAAG,IAAI,EAM1B;IAhBD;;;OAGG;IACH,iBAFa,SAAS,GAAG,IAAI,CAI5B;IAYD;;;;;;OAMG;IACH,4BAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,yCAHW,WAAW,QA4BrB;IAED,mBAMC;IAED;;;;;;;;;OASG;IACH,6BAFW,MAAM,QAQhB;IAED,sCAKC;IAGD,yBAkBC;IAED;;;;OAIG;IACH,UAFa,WAAW,CAKvB;IAED;;;;;;;OAOG;IACH,mBAJW,WAAW,cAEnB;QAA0B,KAAK,GAAvB,OAAO;KACjB,QA6CA;IAED,aAgBC;IAED,aAaC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAlBW,YAAY,GAAC,MAAM,GACjB,GAAG,CAmBf;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAHW,YAAY,GACV;QAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAIzD;IAED;;;;;OAKG;IACH,WAHW,GAAG,GACD,QAAQ,CAIpB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,cACN,SAAS,GACP,OAAO,CAcnB;IAED;;;;;OAKG;IACH,uCAHW,SAAS,GACP,SAAS,GAAC,IAAI,CAe1B;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAI3B;IAED;;;;MA6BC;IAGD,kCAOC;IAED,0BAOC;IAED,sBAmCC;IAED;;;;;;;;;;;OAWG;IACH,kBAJW,MAAM,GACJ,KAAK,CAAC,YAAY,CAAC,CAK/B;IAED;;;;;;;OAOG;IACH,WAFa,QAAQ,CAWpB;IAID,gDAEC;IAGD,uCAEC;IAGD;;;OAGG;IACH,8BAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;;CACD;;;;;gBA5hBa,SAAS;;oCAPb,cAAc;8BAAd,cAAc;+BAAd,cAAc;wBA3BA,yBAAyB;kCA2BvC,cAAc;8BAAd,cAAc;gCAAd,cAAc;kCAAd,cAAc;4BAAd,cAAc"}
+{"version":3,"file":"Session.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Session.svelte.js"],"names":[],"mappings":"AAsCA;;;GAGG;AAEH;IAqCC;;;;;;OAMG;IACH,oBANW,cAAc,OACd,QAAQ,UACR,MAAM,YAEd;QAA4B,SAAS,GAA7B,SAAS;KACnB,EAaA;IApDD,6BAA6B;IAC7B,QADW,cAAc,CACH;IAEtB,uBAAuB;IACvB,KADW,QAAQ,CACA;IAEnB,kBAAkB;IAClB,QADW,GAAG,CACQ;IAEtB,eAAyB;IACzB,sBAA+B;IAC/B,wBAA2C;IAI3C,aAA0B;IAC1B,WAAwB;IAGxB,kBAA6C;IAC7C,kBAAkE;IAGlE,mBAAmD;IACnD,0BAAiE;IACjE,gCAA6E;IAC7E;;;SAAqF;IACrF;;;MAAyF;IACzF;;;SAAiG;IACjG;;;MAEE;IA+BF;;;;OAIG;IACH,qBAHW,SAAS,GAAG,IAAI,EAM1B;IAhBD;;;OAGG;IACH,iBAFa,SAAS,GAAG,IAAI,CAI5B;IAYD;;;;;;OAMG;IACH,4BAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,yCAHW,WAAW,QAsCrB;IAED,mBAQC;IAED;;;;;;;;;OASG;IACH,6BAFW,MAAM,QAQhB;IAED,gCAIC;IAED,sCAIC;IAGD,yBAkBC;IAED;;;;OAIG;IACH,UAFa,WAAW,CAKvB;IAED;;;;;;;OAOG;IACH,mBAJW,WAAW,cAEnB;QAA0B,KAAK,GAAvB,OAAO;KACjB,QAmDA;IAED,aAkBC;IAED,aAaC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAlBW,YAAY,GAAC,MAAM,GACjB,GAAG,CAmBf;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAHW,YAAY,GACV;QAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAIzD;IAED;;;;;OAKG;IACH,WAHW,GAAG,GACD,QAAQ,CAIpB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,cACN,SAAS,GACP,OAAO,CAcnB;IAED;;;;;OAKG;IACH,uCAHW,SAAS,GACP,SAAS,GAAC,IAAI,CAe1B;IAED;;;;;MAqCC;IAED;;;;;MAqCC;IAGD,kCAOC;IAED,0BASC;IAED,sBAmCC;IAED;;;;;;;;;;;OAWG;IACH,kBAJW,MAAM,GACJ,KAAK,CAAC,YAAY,CAAC,CAS/B;IAED;;;;;;;OAOG;IACH,WAFa,QAAQ,CAWpB;IAID,gDAEC;IAGD,uCAEC;IAGD;;;OAGG;IACH,8BAHW,MAAM,GACJ,MAAM,EAAE,CAKpB;;CACD;;;;;gBApmBa,SAAS;;oCAPb,cAAc;8BAAd,cAAc;gCAAd,cAAc;+BAAd,cAAc;wBAjCA,yBAAyB;kCAiCvC,cAAc;8BAAd,cAAc;kCAAd,cAAc;4BAAd,cAAc"}