@rpgjs/map-builder 0.0.0-stage → 5.0.0

package/dist/model/history.d.ts

@@ -0,0 +1,43 @@
+import { MapPatch } from './patches';
+import { ApplyResult, MaybePromise, Unsubscribe } from './result';
+export interface HistoryStatus {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly undoDepth: number;
+    readonly redoDepth: number;
+}
+export interface MapHistory<R extends MaybePromise<ApplyResult> = ApplyResult> {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly status: HistoryStatus;
+    /** Undoes the last action. Returns `null` when there is nothing to undo. */
+    undo(): R | null;
+    /** Redoes the last undone action. Returns `null` when there is nothing to redo. */
+    redo(): R | null;
+    /**
+     * Runs `run`, and undoes everything it applied as one action. Synchronous on
+     * purpose: with a remote committer, use a batch (`model.apply([...])`) instead.
+     */
+    group<T>(run: () => T): T;
+    clear(): void;
+    subscribe(listener: (status: HistoryStatus) => void): Unsubscribe;
+}
+export interface HistoryEntry {
+    readonly patches: readonly MapPatch[];
+    /** Patches that undo `patches`, already in the order they must be applied. */
+    readonly inverse: readonly MapPatch[];
+}
+export interface HistoryOptions<R extends MaybePromise<ApplyResult>> {
+    /** Maximum number of actions kept. `0` disables the history. */
+    readonly limit: number;
+    /** Sends patches through the committer without recording them. */
+    readonly dispatch: (patches: readonly MapPatch[]) => R;
+    readonly onListenerError?: (error: unknown) => void;
+}
+export interface HistoryController<R extends MaybePromise<ApplyResult>> {
+    readonly history: MapHistory<R>;
+    /** Called by the model after a local change was applied. */
+    record(entry: HistoryEntry, coalesce?: string): void;
+}
+export declare function createHistory<R extends MaybePromise<ApplyResult>>(options: HistoryOptions<R>): HistoryController<R>;
+//# sourceMappingURL=history.d.ts.map

package/dist/model/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/model/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAqB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAEpG,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,YAAY,CAAC,WAAW,CAAC,GAAG,WAAW;IAC3E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,4EAA4E;IAC5E,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC;IACjB,mFAAmF;IACnF,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,KAAK,IAAI,IAAI,CAAC;IACd,SAAS,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,WAAW,CAAC;CACnE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,YAAY,CAAC,WAAW,CAAC;IACjE,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,KAAK,CAAC,CAAC;IACvD,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACrD;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,YAAY,CAAC,WAAW,CAAC;IACpE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAChC,4DAA4D;IAC5D,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtD;AAUD,wBAAgB,aAAa,CAAC,CAAC,SAAS,YAAY,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAmInH"}

package/dist/model/history.js

@@ -0,0 +1,141 @@
+import { chain, isThenable } from "./result.js";
+//#region src/model/history.ts
+/** Patches are replayed later, against a different revision: drop the base revision they carried. */
+var withoutRevision = (patches) => patches.map(({ baseRevision: _baseRevision, ...rest }) => rest);
+function createHistory(options) {
+	const { limit, dispatch } = options;
+	let undoStack = [];
+	let redoStack = [];
+	let group = null;
+	let busy = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const status = () => ({
+		canUndo: undoStack.length > 0,
+		canRedo: redoStack.length > 0,
+		undoDepth: undoStack.length,
+		redoDepth: redoStack.length
+	});
+	const notify = () => {
+		const snapshot = status();
+		for (const listener of [...listeners]) try {
+			listener(snapshot);
+		} catch (error) {
+			(options.onListenerError ?? console.error)(error);
+		}
+	};
+	const push = (slot) => {
+		const top = undoStack[undoStack.length - 1];
+		if (slot.coalesce !== void 0 && top?.coalesce === slot.coalesce) undoStack[undoStack.length - 1] = {
+			coalesce: slot.coalesce,
+			patches: [...top.patches, ...slot.patches],
+			inverse: [...slot.inverse, ...top.inverse]
+		};
+		else {
+			undoStack.push(slot);
+			if (undoStack.length > limit) undoStack = undoStack.slice(undoStack.length - limit);
+		}
+		redoStack = [];
+	};
+	const replay = (from) => {
+		const stack = from === "undo" ? undoStack : redoStack;
+		const slot = stack[stack.length - 1];
+		if (!slot || busy) return null;
+		busy = true;
+		const finish = (result) => {
+			busy = false;
+			if (result.ok) {
+				if (from === "undo") {
+					undoStack = undoStack.filter((entry) => entry !== slot);
+					redoStack = [...redoStack, {
+						patches: slot.patches,
+						inverse: slot.inverse
+					}];
+				} else {
+					redoStack = redoStack.filter((entry) => entry !== slot);
+					undoStack = [...undoStack, {
+						patches: slot.patches,
+						inverse: withoutRevision(result.inverse)
+					}];
+				}
+				notify();
+			}
+			return result;
+		};
+		let result;
+		try {
+			result = dispatch(from === "undo" ? slot.inverse : slot.patches);
+		} catch (error) {
+			busy = false;
+			throw error;
+		}
+		if (isThenable(result)) return result.then(finish, (error) => {
+			busy = false;
+			throw error;
+		});
+		return chain(result, finish);
+	};
+	return {
+		history: {
+			get canUndo() {
+				return undoStack.length > 0;
+			},
+			get canRedo() {
+				return redoStack.length > 0;
+			},
+			get status() {
+				return status();
+			},
+			undo: () => replay("undo"),
+			redo: () => replay("redo"),
+			group(run) {
+				if (group) return run();
+				const open = {
+					patches: [],
+					inverse: []
+				};
+				group = open;
+				try {
+					return run();
+				} finally {
+					group = null;
+					if (open.patches.length > 0 && limit > 0) {
+						push({
+							patches: open.patches,
+							inverse: open.inverse
+						});
+						notify();
+					}
+				}
+			},
+			clear() {
+				if (undoStack.length === 0 && redoStack.length === 0) return;
+				undoStack = [];
+				redoStack = [];
+				notify();
+			},
+			subscribe(listener) {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			}
+		},
+		record(entry, coalesce) {
+			if (limit <= 0) return;
+			const patches = withoutRevision(entry.patches);
+			if (group) {
+				group.patches.push(...patches);
+				group.inverse.unshift(...entry.inverse);
+				return;
+			}
+			push({
+				patches,
+				inverse: [...entry.inverse],
+				...coalesce !== void 0 ? { coalesce } : {}
+			});
+			notify();
+		}
+	};
+}
+//#endregion
+export { createHistory };
+
+//# sourceMappingURL=history.js.map

package/dist/model/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","names":[],"sources":["../../src/model/history.ts"],"sourcesContent":["import type { MapPatch } from \"./patches\";\nimport { chain, isThenable, type ApplyResult, type MaybePromise, type Unsubscribe } from \"./result\";\n\nexport interface HistoryStatus {\n  readonly canUndo: boolean;\n  readonly canRedo: boolean;\n  readonly undoDepth: number;\n  readonly redoDepth: number;\n}\n\nexport interface MapHistory<R extends MaybePromise<ApplyResult> = ApplyResult> {\n  readonly canUndo: boolean;\n  readonly canRedo: boolean;\n  readonly status: HistoryStatus;\n  /** Undoes the last action. Returns `null` when there is nothing to undo. */\n  undo(): R | null;\n  /** Redoes the last undone action. Returns `null` when there is nothing to redo. */\n  redo(): R | null;\n  /**\n   * Runs `run`, and undoes everything it applied as one action. Synchronous on\n   * purpose: with a remote committer, use a batch (`model.apply([...])`) instead.\n   */\n  group<T>(run: () => T): T;\n  clear(): void;\n  subscribe(listener: (status: HistoryStatus) => void): Unsubscribe;\n}\n\nexport interface HistoryEntry {\n  readonly patches: readonly MapPatch[];\n  /** Patches that undo `patches`, already in the order they must be applied. */\n  readonly inverse: readonly MapPatch[];\n}\n\nexport interface HistoryOptions<R extends MaybePromise<ApplyResult>> {\n  /** Maximum number of actions kept. `0` disables the history. */\n  readonly limit: number;\n  /** Sends patches through the committer without recording them. */\n  readonly dispatch: (patches: readonly MapPatch[]) => R;\n  readonly onListenerError?: (error: unknown) => void;\n}\n\nexport interface HistoryController<R extends MaybePromise<ApplyResult>> {\n  readonly history: MapHistory<R>;\n  /** Called by the model after a local change was applied. */\n  record(entry: HistoryEntry, coalesce?: string): void;\n}\n\n/** Patches are replayed later, against a different revision: drop the base revision they carried. */\nconst withoutRevision = (patches: readonly MapPatch[]): MapPatch[] =>\n  patches.map(({ baseRevision: _baseRevision, ...rest }) => rest as MapPatch);\n\ninterface Slot extends HistoryEntry {\n  readonly coalesce?: string;\n}\n\nexport function createHistory<R extends MaybePromise<ApplyResult>>(options: HistoryOptions<R>): HistoryController<R> {\n  const { limit, dispatch } = options;\n  let undoStack: Slot[] = [];\n  let redoStack: Slot[] = [];\n  let group: { patches: MapPatch[]; inverse: MapPatch[] } | null = null;\n  let busy = false;\n  const listeners = new Set<(status: HistoryStatus) => void>();\n\n  const status = (): HistoryStatus => ({\n    canUndo: undoStack.length > 0,\n    canRedo: redoStack.length > 0,\n    undoDepth: undoStack.length,\n    redoDepth: redoStack.length,\n  });\n\n  const notify = (): void => {\n    const snapshot = status();\n    for (const listener of [...listeners]) {\n      try {\n        listener(snapshot);\n      } catch (error) {\n        (options.onListenerError ?? console.error)(error);\n      }\n    }\n  };\n\n  const push = (slot: Slot): void => {\n    const top = undoStack[undoStack.length - 1];\n    if (slot.coalesce !== undefined && top?.coalesce === slot.coalesce) {\n      // One continuous edit (a drag, a slider): a single undo step.\n      undoStack[undoStack.length - 1] = {\n        coalesce: slot.coalesce,\n        patches: [...top.patches, ...slot.patches],\n        inverse: [...slot.inverse, ...top.inverse],\n      };\n    } else {\n      undoStack.push(slot);\n      if (undoStack.length > limit) undoStack = undoStack.slice(undoStack.length - limit);\n    }\n    redoStack = [];\n  };\n\n  const replay = (from: \"undo\" | \"redo\"): R | null => {\n    const stack = from === \"undo\" ? undoStack : redoStack;\n    const slot = stack[stack.length - 1];\n    if (!slot || busy) return null;\n\n    busy = true;\n    const finish = (result: ApplyResult): ApplyResult => {\n      busy = false;\n      if (result.ok) {\n        if (from === \"undo\") {\n          undoStack = undoStack.filter((entry) => entry !== slot);\n          redoStack = [...redoStack, { patches: slot.patches, inverse: slot.inverse }];\n        } else {\n          redoStack = redoStack.filter((entry) => entry !== slot);\n          undoStack = [...undoStack, { patches: slot.patches, inverse: withoutRevision(result.inverse) }];\n        }\n        notify();\n      }\n      return result;\n    };\n\n    let result: MaybePromise<ApplyResult>;\n    try {\n      result = dispatch(from === \"undo\" ? slot.inverse : slot.patches);\n    } catch (error) {\n      busy = false;\n      throw error;\n    }\n    if (isThenable(result)) {\n      return result.then(finish, (error) => {\n        busy = false;\n        throw error;\n      }) as R;\n    }\n    return chain(result, finish) as R;\n  };\n\n  const history: MapHistory<R> = {\n    get canUndo() {\n      return undoStack.length > 0;\n    },\n    get canRedo() {\n      return redoStack.length > 0;\n    },\n    get status() {\n      return status();\n    },\n    undo: () => replay(\"undo\"),\n    redo: () => replay(\"redo\"),\n    group<T>(run: () => T): T {\n      if (group) return run();\n      const open = { patches: [] as MapPatch[], inverse: [] as MapPatch[] };\n      group = open;\n      try {\n        return run();\n      } finally {\n        group = null;\n        if (open.patches.length > 0 && limit > 0) {\n          push({ patches: open.patches, inverse: open.inverse });\n          notify();\n        }\n      }\n    },\n    clear() {\n      if (undoStack.length === 0 && redoStack.length === 0) return;\n      undoStack = [];\n      redoStack = [];\n      notify();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n\n  return {\n    history,\n    record(entry, coalesce) {\n      if (limit <= 0) return;\n      const patches = withoutRevision(entry.patches);\n      if (group) {\n        group.patches.push(...patches);\n        group.inverse.unshift(...entry.inverse);\n        return;\n      }\n      push({ patches, inverse: [...entry.inverse], ...(coalesce !== undefined ? { coalesce } : {}) });\n      notify();\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/model/index.d.ts

@@ -0,0 +1,14 @@
+export * from './json';
+export * from './definition';
+export * from './errors';
+export * from './parse';
+export * from './assets';
+export * from './define-map';
+export * from './patches';
+export * from './result';
+export * from './history';
+export * from './committer';
+export * from './model';
+export * from './source';
+export { coreHandlers } from './core-patches';
+//# sourceMappingURL=index.d.ts.map

package/dist/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/model/index.js

@@ -0,0 +1,14 @@
+import { cloneJson, isFiniteNumberValue, isJsonObject, isJsonValue, isPlainObject } from "./json.js";
+import { MAP_DEFINITION_VERSION } from "./definition.js";
+import { MapDefinitionError } from "./errors.js";
+import { checkPlaced, defaultMapMigrations, isScale, parseMapDefinition } from "./parse.js";
+import { defineAssets } from "./assets.js";
+import { defineMap, el, event } from "./define-map.js";
+import { definePatchHandlers, patchFail, patchOk } from "./patches.js";
+import { chain, isThenable } from "./result.js";
+import { createHistory } from "./history.js";
+import { localCommitter } from "./committer.js";
+import { coreHandlers } from "./core-patches.js";
+import { DEFAULT_HISTORY_LIMIT, createMapModel } from "./model.js";
+import { MapSourceError, codeMapSource, httpMapSource, jsonMapSource, loadMapRegion, regionOf } from "./source.js";
+export { DEFAULT_HISTORY_LIMIT, MAP_DEFINITION_VERSION, MapDefinitionError, MapSourceError, chain, checkPlaced, cloneJson, codeMapSource, coreHandlers, createHistory, createMapModel, defaultMapMigrations, defineAssets, defineMap, definePatchHandlers, el, event, httpMapSource, isFiniteNumberValue, isJsonObject, isJsonValue, isPlainObject, isScale, isThenable, jsonMapSource, loadMapRegion, localCommitter, parseMapDefinition, patchFail, patchOk, regionOf };

package/dist/model/json.d.ts

@@ -0,0 +1,15 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** True when `value` survives `JSON.stringify` / `JSON.parse` unchanged. */
+export declare function isJsonValue(value: unknown): value is JsonValue;
+export declare function isJsonObject(value: unknown): value is JsonObject;
+/** Deep copy of a JSON value, so that callers never share structure with the model. */
+export declare function cloneJson<T extends JsonValue>(value: T): T;
+export declare function isFiniteNumberValue(value: unknown): value is number;
+//# sourceMappingURL=json.d.ts.map

package/dist/model/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/model/json.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,SAAS,SAAS,EAAE,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AACrG,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAE/D,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAI9E;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAe9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAED,uFAAuF;AACvF,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAW1D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEnE"}

package/dist/model/json.js

@@ -0,0 +1,35 @@
+//#region src/model/json.ts
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/** True when `value` survives `JSON.stringify` / `JSON.parse` unchanged. */
+function isJsonValue(value) {
+	if (value === null) return true;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return true;
+		case "number": return Number.isFinite(value);
+		case "object":
+			if (Array.isArray(value)) return value.every(isJsonValue);
+			return isPlainObject(value) && Object.values(value).every((item) => item === void 0 || isJsonValue(item));
+		default: return false;
+	}
+}
+function isJsonObject(value) {
+	return isPlainObject(value) && isJsonValue(value);
+}
+/** Deep copy of a JSON value, so that callers never share structure with the model. */
+function cloneJson(value) {
+	if (Array.isArray(value)) return value.map((item) => cloneJson(item));
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, cloneJson(item)]));
+	return value;
+}
+function isFiniteNumberValue(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+//#endregion
+export { cloneJson, isFiniteNumberValue, isJsonObject, isJsonValue, isPlainObject };
+
+//# sourceMappingURL=json.js.map

package/dist/model/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","names":[],"sources":["../../src/model/json.ts"],"sourcesContent":["export type JsonPrimitive = string | number | boolean | null;\nexport type JsonValue = JsonPrimitive | readonly JsonValue[] | { readonly [key: string]: JsonValue };\nexport type JsonObject = { readonly [key: string]: JsonValue };\n\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null) return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n/** True when `value` survives `JSON.stringify` / `JSON.parse` unchanged. */\nexport function isJsonValue(value: unknown): value is JsonValue {\n  if (value === null) return true;\n  switch (typeof value) {\n    case \"string\":\n    case \"boolean\":\n      return true;\n    case \"number\":\n      return Number.isFinite(value);\n    case \"object\":\n      if (Array.isArray(value)) return value.every(isJsonValue);\n      // A property set to `undefined` is dropped by `JSON.stringify`, so it counts as absent.\n      return isPlainObject(value) && Object.values(value).every((item) => item === undefined || isJsonValue(item));\n    default:\n      return false;\n  }\n}\n\nexport function isJsonObject(value: unknown): value is JsonObject {\n  return isPlainObject(value) && isJsonValue(value);\n}\n\n/** Deep copy of a JSON value, so that callers never share structure with the model. */\nexport function cloneJson<T extends JsonValue>(value: T): T {\n  if (Array.isArray(value)) return value.map((item) => cloneJson(item)) as unknown as T;\n  if (value !== null && typeof value === \"object\") {\n    // `fromEntries` defines own properties, so a `__proto__` key can never reach the prototype.\n    return Object.fromEntries(\n      Object.entries(value)\n        .filter(([, item]) => item !== undefined)\n        .map(([key, item]) => [key, cloneJson(item as JsonValue)]),\n    ) as unknown as T;\n  }\n  return value;\n}\n\nexport function isFiniteNumberValue(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isFinite(value);\n}\n"],"mappings":";AAIA,SAAgB,cAAc,OAAkD;CAC9E,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,OAAO,UAAU,OAAO,aAAa,UAAU;AACjD;;AAGA,SAAgB,YAAY,OAAoC;CAC9D,IAAI,UAAU,MAAM,OAAO;CAC3B,QAAQ,OAAO,OAAf;EACE,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK,UACH,OAAO,OAAO,SAAS,KAAK;EAC9B,KAAK;GACH,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,MAAM,WAAW;GAExD,OAAO,cAAc,KAAK,KAAK,OAAO,OAAO,KAAK,CAAC,CAAC,OAAO,SAAS,SAAS,KAAA,KAAa,YAAY,IAAI,CAAC;EAC7G,SACE,OAAO;CACX;AACF;AAEA,SAAgB,aAAa,OAAqC;CAChE,OAAO,cAAc,KAAK,KAAK,YAAY,KAAK;AAClD;;AAGA,SAAgB,UAA+B,OAAa;CAC1D,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,KAAK,SAAS,UAAU,IAAI,CAAC;CACpE,IAAI,UAAU,QAAQ,OAAO,UAAU,UAErC,OAAO,OAAO,YACZ,OAAO,QAAQ,KAAK,CAAC,CAClB,QAAQ,GAAG,UAAU,SAAS,KAAA,CAAS,CAAC,CACxC,KAAK,CAAC,KAAK,UAAU,CAAC,KAAK,UAAU,IAAiB,CAAC,CAAC,CAC7D;CAEF,OAAO;AACT;AAEA,SAAgB,oBAAoB,OAAiC;CACnE,OAAO,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK;AAC3D"}

package/dist/model/model.d.ts

@@ -0,0 +1,68 @@
+import { MapCommitter } from './committer';
+import { MapDefinition, MapElement, MapEvent, MapState } from './definition';
+import { MapHistory } from './history';
+import { MapPatch, PatchHandlers } from './patches';
+import { ApplyResult, MaybePromise, Unsubscribe } from './result';
+export interface MapChange {
+    readonly revision: number;
+    readonly patches: readonly MapPatch[];
+    readonly inverse: readonly MapPatch[];
+    readonly origin: "local" | "remote";
+    /** State after the change. */
+    readonly state: MapState;
+    /**
+     * The whole state was replaced (a snapshot from the authority): `patches` is empty
+     * and whatever was derived from the previous state must be rebuilt.
+     */
+    readonly reset?: true;
+}
+export interface ApplyOptions {
+    /** Consecutive `apply` calls with the same key become one undo step (a drag, a slider). */
+    readonly coalesce?: string;
+    /** The intents the patches come from. A committer that talks to an authority sends these. */
+    readonly intents?: readonly unknown[];
+}
+export interface MapModelOptions {
+    readonly committer?: MapCommitter<ApplyResult>;
+    /** Handlers for the patch types features add. They cannot replace a built-in one. */
+    readonly patchHandlers?: readonly PatchHandlers[];
+    /** Revision the map starts at, e.g. the one of a server snapshot. Defaults to 0. */
+    readonly revision?: number;
+    /** Maximum number of undoable actions, or `false` to disable the history. Defaults to 50. */
+    readonly history?: {
+        readonly limit?: number;
+    } | false;
+    /**
+     * What to do with a patch computed against another revision than the current one:
+     * `"reject"` (default) or `"rebase"` (apply it anyway, if it is still valid).
+     */
+    readonly onStale?: "reject" | "rebase";
+    readonly onListenerError?: (error: unknown) => void;
+}
+export interface MapModel<R extends MaybePromise<ApplyResult> = ApplyResult> {
+    /** Current state. Immutable: every change produces a new object. */
+    readonly state: MapState;
+    readonly revision: number;
+    readonly history: MapHistory<R>;
+    /**
+     * Submits an intention. It goes through the committer, which decides where it
+     * becomes a fact. A batch (an array) is atomic: all or nothing, one revision.
+     */
+    apply(input: MapPatch | readonly MapPatch[], options?: ApplyOptions): R;
+    /** Deep copy of the current state, safe to serialize or mutate. */
+    getDefinition(): MapDefinition;
+    getElement(id: string): MapElement | undefined;
+    getEvent(id: string): MapEvent | undefined;
+    /** Framework-neutral: plugs into Angular signals, Vue, React or CanvasEngine. */
+    subscribe(listener: (change: MapChange) => void): Unsubscribe;
+}
+export declare const DEFAULT_HISTORY_LIMIT = 50;
+/**
+ * Creates the model of a map: the single source of truth, changed only by patches.
+ * The definition is validated and copied, so the model never shares structure with the caller.
+ */
+export declare function createMapModel(definition: MapDefinition, options?: MapModelOptions): MapModel<ApplyResult>;
+export declare function createMapModel<R extends MaybePromise<ApplyResult>>(definition: MapDefinition, options: Omit<MapModelOptions, "committer"> & {
+    readonly committer: MapCommitter<R>;
+}): MapModel<R>;
+//# sourceMappingURL=model.d.ts.map

package/dist/model/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/model/model.ts"],"names":[],"mappings":"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"}

package/dist/model/model.js

@@ -0,0 +1,170 @@
+import { cloneJson } from "./json.js";
+import { parseMapDefinition } from "./parse.js";
+import { createHistory } from "./history.js";
+import { localCommitter } from "./committer.js";
+import { coreHandlers } from "./core-patches.js";
+//#region src/model/model.ts
+var DEFAULT_HISTORY_LIMIT = 50;
+var reject = (rejection) => ({
+	ok: false,
+	rejection
+});
+function createMapModel(definition, options = {}) {
+	const committer = options.committer ?? localCommitter();
+	const onStale = options.onStale ?? "reject";
+	const reportListenerError = options.onListenerError ?? ((error) => console.error(error));
+	const handlers = /* @__PURE__ */ new Map();
+	const register = (set, locked) => {
+		for (const [type, handler] of Object.entries(set)) {
+			if (!handler) continue;
+			if (locked && handlers.has(type)) throw new Error(`Patch type "${type}" is already handled`);
+			handlers.set(type, handler);
+		}
+	};
+	register(coreHandlers, false);
+	for (const set of options.patchHandlers ?? []) register(set, true);
+	let state = parseMapDefinition(definition);
+	let revision = options.revision ?? 0;
+	const listeners = /* @__PURE__ */ new Set();
+	const controller = createHistory({
+		limit: options.history === false ? 0 : options.history?.limit ?? 50,
+		dispatch: (patches) => committer.commit({
+			patches,
+			record: false
+		}),
+		onListenerError: reportListenerError
+	});
+	function integrate(patches, integrateOptions = {}) {
+		const origin = integrateOptions.origin ?? "local";
+		if (patches.length === 0) return reject({
+			code: "invalid-patch",
+			message: "A batch must contain at least one patch"
+		});
+		const malformed = patches.findIndex((patch) => typeof patch !== "object" || patch === null);
+		if (malformed >= 0) return reject({
+			code: "invalid-patch",
+			message: "A patch must be an object",
+			patchIndex: malformed
+		});
+		if (onStale === "reject") {
+			const index = patches.findIndex((patch) => patch.baseRevision !== void 0 && patch.baseRevision !== revision);
+			if (index >= 0) return reject({
+				code: "stale-revision",
+				message: `Patch was computed against revision ${patches[index].baseRevision}, current revision is ${revision}`,
+				patchIndex: index
+			});
+		}
+		if (integrateOptions.revision !== void 0 && integrateOptions.revision !== revision + 1) return reject({
+			code: "revision-gap",
+			message: `Expected revision ${revision + 1}, got ${integrateOptions.revision}`
+		});
+		let draft = state;
+		let inverse = [];
+		for (const [index, patch] of patches.entries()) {
+			const handler = typeof patch?.type === "string" ? handlers.get(patch.type) : void 0;
+			if (!handler) return reject({
+				code: "unknown-patch",
+				message: `No handler for patch type "${String(patch?.type)}"`,
+				patchIndex: index
+			});
+			let outcome;
+			try {
+				outcome = handler.apply(draft, patch);
+			} catch (error) {
+				return reject({
+					code: "invalid-patch",
+					message: error instanceof Error ? error.message : String(error),
+					patchIndex: index
+				});
+			}
+			if (!outcome.ok) return reject({
+				...outcome.rejection,
+				patchIndex: index
+			});
+			draft = outcome.state;
+			inverse = [...outcome.inverse, ...inverse];
+		}
+		state = draft;
+		revision = integrateOptions.revision ?? revision + 1;
+		const result = {
+			ok: true,
+			revision,
+			patches,
+			inverse
+		};
+		if (origin === "local" && integrateOptions.record !== false) controller.record({
+			patches,
+			inverse
+		}, integrateOptions.coalesce);
+		const change = {
+			revision,
+			patches,
+			inverse,
+			origin,
+			state
+		};
+		for (const listener of [...listeners]) try {
+			listener(change);
+		} catch (error) {
+			reportListenerError(error);
+		}
+		return result;
+	}
+	const host = {
+		get state() {
+			return state;
+		},
+		get revision() {
+			return revision;
+		},
+		integrate,
+		reset(next, nextRevision) {
+			state = parseMapDefinition(next);
+			revision = nextRevision;
+			controller.history.clear();
+			const change = {
+				revision,
+				patches: [],
+				inverse: [],
+				origin: "remote",
+				state,
+				reset: true
+			};
+			for (const listener of [...listeners]) try {
+				listener(change);
+			} catch (error) {
+				reportListenerError(error);
+			}
+		}
+	};
+	committer.attach(host);
+	return {
+		get state() {
+			return state;
+		},
+		get revision() {
+			return revision;
+		},
+		history: controller.history,
+		apply(input, applyOptions) {
+			const patches = Array.isArray(input) ? input : [input];
+			return committer.commit({
+				patches,
+				record: true,
+				...applyOptions?.coalesce !== void 0 ? { coalesce: applyOptions.coalesce } : {},
+				...applyOptions?.intents !== void 0 ? { intents: applyOptions.intents } : {}
+			});
+		},
+		getDefinition: () => cloneJson(state),
+		getElement: (id) => state.elements.find((element) => element.id === id),
+		getEvent: (id) => state.events.find((entry) => entry.id === id),
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+//#endregion
+export { DEFAULT_HISTORY_LIMIT, createMapModel };
+
+//# sourceMappingURL=model.js.map

package/dist/model/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","names":[],"sources":["../../src/model/model.ts"],"sourcesContent":["import { localCommitter, type CommitHost, type IntegrateOptions, type MapCommitter } from \"./committer\";\nimport { coreHandlers } from \"./core-patches\";\nimport type { MapDefinition, MapElement, MapEvent, MapState } from \"./definition\";\nimport type { MapRejection } from \"./errors\";\nimport { createHistory, type MapHistory } from \"./history\";\nimport { cloneJson, type JsonValue } from \"./json\";\nimport { parseMapDefinition } from \"./parse\";\nimport type { MapPatch, PatchHandler, PatchHandlers, PatchType } from \"./patches\";\nimport type { ApplyFailure, ApplyResult, MaybePromise, Unsubscribe } from \"./result\";\n\nexport interface MapChange {\n  readonly revision: number;\n  readonly patches: readonly MapPatch[];\n  readonly inverse: readonly MapPatch[];\n  readonly origin: \"local\" | \"remote\";\n  /** State after the change. */\n  readonly state: MapState;\n  /**\n   * The whole state was replaced (a snapshot from the authority): `patches` is empty\n   * and whatever was derived from the previous state must be rebuilt.\n   */\n  readonly reset?: true;\n}\n\nexport interface ApplyOptions {\n  /** Consecutive `apply` calls with the same key become one undo step (a drag, a slider). */\n  readonly coalesce?: string;\n  /** The intents the patches come from. A committer that talks to an authority sends these. */\n  readonly intents?: readonly unknown[];\n}\n\nexport interface MapModelOptions {\n  readonly committer?: MapCommitter<ApplyResult>;\n  /** Handlers for the patch types features add. They cannot replace a built-in one. */\n  readonly patchHandlers?: readonly PatchHandlers[];\n  /** Revision the map starts at, e.g. the one of a server snapshot. Defaults to 0. */\n  readonly revision?: number;\n  /** Maximum number of undoable actions, or `false` to disable the history. Defaults to 50. */\n  readonly history?: { readonly limit?: number } | false;\n  /**\n   * What to do with a patch computed against another revision than the current one:\n   * `\"reject\"` (default) or `\"rebase\"` (apply it anyway, if it is still valid).\n   */\n  readonly onStale?: \"reject\" | \"rebase\";\n  readonly onListenerError?: (error: unknown) => void;\n}\n\nexport interface MapModel<R extends MaybePromise<ApplyResult> = ApplyResult> {\n  /** Current state. Immutable: every change produces a new object. */\n  readonly state: MapState;\n  readonly revision: number;\n  readonly history: MapHistory<R>;\n  /**\n   * Submits an intention. It goes through the committer, which decides where it\n   * becomes a fact. A batch (an array) is atomic: all or nothing, one revision.\n   */\n  apply(input: MapPatch | readonly MapPatch[], options?: ApplyOptions): R;\n  /** Deep copy of the current state, safe to serialize or mutate. */\n  getDefinition(): MapDefinition;\n  getElement(id: string): MapElement | undefined;\n  getEvent(id: string): MapEvent | undefined;\n  /** Framework-neutral: plugs into Angular signals, Vue, React or CanvasEngine. */\n  subscribe(listener: (change: MapChange) => void): Unsubscribe;\n}\n\nexport const DEFAULT_HISTORY_LIMIT = 50;\n\nconst reject = (rejection: MapRejection): ApplyFailure => ({ ok: false, rejection });\n\n/**\n * Creates the model of a map: the single source of truth, changed only by patches.\n * The definition is validated and copied, so the model never shares structure with the caller.\n */\nexport function createMapModel(definition: MapDefinition, options?: MapModelOptions): MapModel<ApplyResult>;\nexport function createMapModel<R extends MaybePromise<ApplyResult>>(\n  definition: MapDefinition,\n  options: Omit<MapModelOptions, \"committer\"> & { readonly committer: MapCommitter<R> },\n): MapModel<R>;\nexport function createMapModel(\n  definition: MapDefinition,\n  options: Omit<MapModelOptions, \"committer\"> & { readonly committer?: MapCommitter<MaybePromise<ApplyResult>> } = {},\n): MapModel<MaybePromise<ApplyResult>> {\n  type R = MaybePromise<ApplyResult>;\n  const committer: MapCommitter<R> = options.committer ?? localCommitter();\n  const onStale = options.onStale ?? \"reject\";\n  const reportListenerError = options.onListenerError ?? ((error: unknown) => console.error(error));\n\n  const handlers = new Map<string, PatchHandler<PatchType>>();\n  const register = (set: PatchHandlers, locked: boolean): void => {\n    for (const [type, handler] of Object.entries(set)) {\n      if (!handler) continue;\n      if (locked && handlers.has(type)) throw new Error(`Patch type \"${type}\" is already handled`);\n      handlers.set(type, handler as PatchHandler<PatchType>);\n    }\n  };\n  register(coreHandlers, false);\n  for (const set of options.patchHandlers ?? []) register(set, true);\n\n  let state: MapState = parseMapDefinition(definition);\n  let revision = options.revision ?? 0;\n  const listeners = new Set<(change: MapChange) => void>();\n\n  const limit = options.history === false ? 0 : (options.history?.limit ?? DEFAULT_HISTORY_LIMIT);\n  const controller = createHistory<R>({\n    limit,\n    dispatch: (patches) => committer.commit({ patches, record: false }),\n    onListenerError: reportListenerError,\n  });\n\n  function integrate(patches: readonly MapPatch[], integrateOptions: IntegrateOptions = {}): ApplyResult {\n    const origin = integrateOptions.origin ?? \"local\";\n    if (patches.length === 0) {\n      return reject({ code: \"invalid-patch\", message: \"A batch must contain at least one patch\" });\n    }\n\n    // Patches may come from the network: never trust their shape.\n    const malformed = patches.findIndex((patch) => typeof patch !== \"object\" || patch === null);\n    if (malformed >= 0) {\n      return reject({ code: \"invalid-patch\", message: \"A patch must be an object\", patchIndex: malformed });\n    }\n\n    if (onStale === \"reject\") {\n      const index = patches.findIndex((patch) => patch.baseRevision !== undefined && patch.baseRevision !== revision);\n      if (index >= 0) {\n        return reject({\n          code: \"stale-revision\",\n          message: `Patch was computed against revision ${patches[index]!.baseRevision}, current revision is ${revision}`,\n          patchIndex: index,\n        });\n      }\n    }\n    if (integrateOptions.revision !== undefined && integrateOptions.revision !== revision + 1) {\n      return reject({\n        code: \"revision-gap\",\n        message: `Expected revision ${revision + 1}, got ${integrateOptions.revision}`,\n      });\n    }\n\n    // Handlers are pure, so working on a draft makes the batch atomic.\n    let draft = state;\n    let inverse: readonly MapPatch[] = [];\n    for (const [index, patch] of patches.entries()) {\n      const handler = typeof patch?.type === \"string\" ? handlers.get(patch.type) : undefined;\n      if (!handler) {\n        return reject({\n          code: \"unknown-patch\",\n          message: `No handler for patch type \"${String(patch?.type)}\"`,\n          patchIndex: index,\n        });\n      }\n      let outcome;\n      try {\n        outcome = handler.apply(draft, patch as never);\n      } catch (error) {\n        return reject({\n          code: \"invalid-patch\",\n          message: error instanceof Error ? error.message : String(error),\n          patchIndex: index,\n        });\n      }\n      if (!outcome.ok) return reject({ ...outcome.rejection, patchIndex: index });\n      draft = outcome.state;\n      // The inverse of a later patch must run before the inverse of an earlier one.\n      inverse = [...outcome.inverse, ...inverse];\n    }\n\n    state = draft;\n    revision = integrateOptions.revision ?? revision + 1;\n    const result: ApplyResult = { ok: true, revision, patches, inverse };\n\n    if (origin === \"local\" && integrateOptions.record !== false) {\n      controller.record({ patches, inverse }, integrateOptions.coalesce);\n    }\n    const change: MapChange = { revision, patches, inverse, origin, state };\n    for (const listener of [...listeners]) {\n      try {\n        listener(change);\n      } catch (error) {\n        reportListenerError(error);\n      }\n    }\n    return result;\n  }\n\n  const host: CommitHost = {\n    get state() {\n      return state;\n    },\n    get revision() {\n      return revision;\n    },\n    integrate,\n    reset(next, nextRevision) {\n      state = parseMapDefinition(next);\n      revision = nextRevision;\n      controller.history.clear();\n      const change: MapChange = { revision, patches: [], inverse: [], origin: \"remote\", state, reset: true };\n      for (const listener of [...listeners]) {\n        try {\n          listener(change);\n        } catch (error) {\n          reportListenerError(error);\n        }\n      }\n    },\n  };\n  committer.attach(host);\n\n  return {\n    get state() {\n      return state;\n    },\n    get revision() {\n      return revision;\n    },\n    history: controller.history,\n    apply(input, applyOptions) {\n      const patches = Array.isArray(input) ? (input as readonly MapPatch[]) : [input as MapPatch];\n      return committer.commit({\n        patches,\n        record: true,\n        ...(applyOptions?.coalesce !== undefined ? { coalesce: applyOptions.coalesce } : {}),\n        ...(applyOptions?.intents !== undefined ? { intents: applyOptions.intents } : {}),\n      });\n    },\n    getDefinition: () => cloneJson(state as unknown as JsonValue) as unknown as MapDefinition,\n    getElement: (id) => state.elements.find((element) => element.id === id),\n    getEvent: (id) => state.events.find((entry) => entry.id === id),\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/model/parse.d.ts

@@ -0,0 +1,24 @@
+import { MapDefinition } from './definition';
+import { MapIssue } from './errors';
+/** Upgrades a raw definition from version `n` to version `n + 1`. */
+export type MapMigration = (raw: Record<string, unknown>) => Record<string, unknown>;
+/** Migrations keyed by the version they upgrade *from*. Empty until version 2 exists. */
+export declare const defaultMapMigrations: Readonly<Record<number, MapMigration>>;
+export interface ParseMapOptions {
+    readonly migrations?: Readonly<Record<number, MapMigration>>;
+    readonly currentVersion?: number;
+}
+/** A positive number, or `[x, y]` of positive numbers. */
+export declare const isScale: (value: unknown) => boolean;
+/** Problems found in one element or event, with paths relative to `path`. */
+export declare function checkPlaced(value: unknown, path: string, kind: "element" | "event"): MapIssue[];
+/**
+ * Validates, migrates and copies a raw definition (for instance parsed JSON).
+ *
+ * - The result shares no structure with the input.
+ * - Fields unknown to this version are preserved, so an older tool never destroys
+ *   data written by a newer one.
+ * - Throws {@link MapDefinitionError} listing every problem found.
+ */
+export declare function parseMapDefinition(raw: unknown, options?: ParseMapOptions): MapDefinition;
+//# sourceMappingURL=parse.d.ts.map

package/dist/model/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/model/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAG7D,qEAAqE;AACrE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAErF,yFAAyF;AACzF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAM,CAAC;AAE/E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAID,0DAA0D;AAC1D,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,OACqD,CAAC;AAG/F,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,QAAQ,EAAE,CA6B/F;AAyDD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,aAAa,CAqC7F"}