@novely/core 0.54.0 → 0.55.0

package/dist/index.mjs

@@ -0,0 +1,2623 @@
+import { dequal } from "dequal/lite";
+import { memoize, once, throttle } from "es-toolkit/function";
+import { merge } from "es-toolkit/object";
+import { DEV } from "esm-env";
+import { klona } from "klona/full";
+import pLimit from "p-limit";
+
+//#region src/constants.ts
+const SKIPPED_DURING_RESTORE = new Set([
+	"dialog",
+	"choice",
+	"input",
+	"vibrate",
+	"text"
+]);
+const BLOCK_EXIT_STATEMENTS = new Set([
+	"choice:exit",
+	"condition:exit",
+	"block:exit"
+]);
+const BLOCK_STATEMENTS = new Set([
+	"choice",
+	"condition",
+	"block"
+]);
+const AUDIO_ACTIONS = new Set([
+	"playMusic",
+	"stopMusic",
+	"playSound",
+	"stopSound",
+	"voice",
+	"stopVoice"
+]);
+const EMPTY_SET = /* @__PURE__ */ new Set();
+const DEFAULT_TYPEWRITER_SPEED = "Medium";
+const HOWLER_SUPPORTED_FILE_FORMATS = new Set([
+	"mp3",
+	"mpeg",
+	"opus",
+	"ogg",
+	"oga",
+	"wav",
+	"aac",
+	"caf",
+	"m4a",
+	"m4b",
+	"mp4",
+	"weba",
+	"webm",
+	"dolby",
+	"flac"
+]);
+const SUPPORTED_IMAGE_FILE_FORMATS = new Set([
+	"apng",
+	"avif",
+	"gif",
+	"jpg",
+	"jpeg",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"png",
+	"svg",
+	"webp",
+	"bmp"
+]);
+/**
+* @internal
+*/
+const MAIN_CONTEXT_KEY = "$MAIN";
+
+//#endregion
+//#region src/shared.ts
+/**
+* @internal
+*/
+const STACK_MAP = /* @__PURE__ */ new Map();
+/**
+* @internal
+*/
+const CUSTOM_ACTION_MAP = /* @__PURE__ */ new Map();
+/**
+* @internal
+*/
+const CUSTOM_ACTION_INSTANCES_MAP = /* @__PURE__ */ new Map();
+const PRELOADED_ASSETS = /* @__PURE__ */ new Set();
+const ASSETS_TO_PRELOAD = /* @__PURE__ */ new Set();
+
+//#endregion
+//#region src/utilities/assertions.ts
+const isNumber = (val) => {
+	return typeof val === "number";
+};
+const isNull = (val) => {
+	return val === null;
+};
+const isString = (val) => {
+	return typeof val === "string";
+};
+const isFunction = (val) => {
+	return typeof val === "function";
+};
+const isPromise = (val) => {
+	return Boolean(val) && (typeof val === "object" || isFunction(val)) && isFunction(val.then);
+};
+const isEmpty = (val) => {
+	return typeof val === "object" && !isNull(val) && Object.keys(val).length === 0;
+};
+/**
+* Determines if a given action requires user interaction based on its type and metadata.
+*/
+const isUserRequiredAction = ([action, ...meta]) => {
+	return Boolean(action === "custom" && meta[0] && meta[0].requireUserAction);
+};
+const isBlockStatement = (statement) => {
+	return BLOCK_STATEMENTS.has(statement);
+};
+const isBlockExitStatement = (statement) => {
+	return BLOCK_EXIT_STATEMENTS.has(statement);
+};
+const isSkippedDuringRestore = (item) => {
+	return SKIPPED_DURING_RESTORE.has(item);
+};
+const isAudioAction = (action) => {
+	return AUDIO_ACTIONS.has(action);
+};
+const isAction = (element) => {
+	return Array.isArray(element) && isString(element[0]);
+};
+/**
+* Is custom and requires user action or skipped during restoring
+*/
+const isBlockingAction = (action) => {
+	return isUserRequiredAction(action) || isSkippedDuringRestore(action[0]) && action[0] !== "vibrate";
+};
+const isAsset = (suspect) => {
+	return suspect !== null && typeof suspect === "object" && "source" in suspect && "type" in suspect;
+};
+
+//#endregion
+//#region src/utilities/match-action.ts
+const matchAction = (handlers, values) => {
+	const { getContext, onBeforeActionCall, push, forward } = handlers;
+	const match = (action, props, { ctx, data }) => {
+		const context = typeof ctx === "string" ? getContext(ctx) : ctx;
+		onBeforeActionCall({
+			action,
+			props,
+			ctx: context
+		});
+		return values[action]({
+			ctx: context,
+			data,
+			async push() {
+				if (context.meta.preview) return;
+				await push(context);
+			},
+			async forward() {
+				if (context.meta.preview) return;
+				await forward(context);
+			}
+		}, props);
+	};
+	return {
+		match,
+		nativeActions: Object.keys(values)
+	};
+};
+
+//#endregion
+//#region src/audio-codecs.ts
+/**
+* This code is adapted from the Howler.js source code.
+* Howler.js: https://github.com/goldfire/howler.js
+*/
+/**
+* I guess some browsers will return "no". So it's better to be safe
+*/
+const cut = (str) => str.replace(/^no$/, "");
+const audio = new Audio();
+const canPlay = (type) => !!cut(audio.canPlayType(type));
+const canPlayMultiple = (...types) => types.some((type) => canPlay(type));
+const supportsMap$1 = {
+	mp3: canPlayMultiple("audio/mpeg;", "audio/mp3;"),
+	mpeg: canPlay("audio/mpeg;"),
+	opus: canPlay("audio/ogg; codecs=\"opus\""),
+	ogg: canPlay("audio/ogg; codecs=\"vorbis\""),
+	oga: canPlay("audio/ogg; codecs=\"vorbis\""),
+	wav: canPlayMultiple("audio/wav; codecs=\"1\"", "audio/wav;"),
+	aac: canPlay("audio/aac;"),
+	caf: canPlay("audio/x-caf;"),
+	m4a: canPlayMultiple("audio/x-m4a;", "audio/m4a;", "audio/aac;"),
+	m4b: canPlayMultiple("audio/x-m4b;", "audio/m4b;", "audio/aac;"),
+	mp4: canPlayMultiple("audio/x-mp4;", "audio/mp4;", "audio/aac;"),
+	weba: canPlay("audio/webm; codecs=\"vorbis\""),
+	webm: canPlay("audio/webm; codecs=\"vorbis\""),
+	dolby: canPlay("audio/mp4; codecs=\"ec-3\""),
+	flac: canPlayMultiple("audio/x-flac;", "audio/flac;")
+};
+
+//#endregion
+//#region src/image-formats.ts
+const avif = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=";
+const jxl = "data:image/jxl;base64,/woIAAAMABKIAgC4AF3lEgAAFSqjjBu8nOv58kOHxbSN6wxttW1hSaLIODZJJ3BIEkkaoCUzGM6qJAE=";
+const webp = "data:image/webp;base64,UklGRjoAAABXRUJQVlA4IC4AAACyAgCdASoCAAIALmk0mk0iIiIiIgBoSygABc6WWgAA/veff/0PP8bA//LwYAAA";
+const supportsFormat = (source) => {
+	const { promise, resolve } = Promise.withResolvers();
+	const img = Object.assign(document.createElement("img"), { src: source });
+	img.onload = img.onerror = () => {
+		resolve(img.height === 2);
+	};
+	return promise;
+};
+const supportsMap = {
+	avif: false,
+	jxl: false,
+	webp: false
+};
+const formatsMap = {
+	avif,
+	jxl,
+	webp
+};
+const loadImageFormatsSupport = async () => {
+	const promises = [];
+	for (const [format, source] of Object.entries(formatsMap)) {
+		const promise = supportsFormat(source).then((supported) => {
+			supportsMap[format] = supported;
+		});
+		promises.push(promise);
+	}
+	await Promise.all(promises);
+};
+loadImageFormatsSupport();
+
+//#endregion
+//#region src/asset.ts
+const generateRandomId = () => Math.random().toString(36);
+/**
+* Function to get assets type. All assets must be of the same type. Only works with supported types.
+*/
+const getType = memoize((extensions) => {
+	if (extensions.every((extension) => HOWLER_SUPPORTED_FILE_FORMATS.has(extension))) return "audio";
+	if (extensions.every((extension) => SUPPORTED_IMAGE_FILE_FORMATS.has(extension))) return "image";
+	if (DEV) throw new Error(`Unsupported file extensions: ${JSON.stringify(extensions)}`);
+	throw extensions;
+}, { getCacheKey: (extensions) => extensions.join("~") });
+const SUPPORT_MAPS = {
+	image: supportsMap,
+	audio: supportsMap$1
+};
+/**
+* This function uses array instead of spread because memoize only works with first argument
+*/
+const assetPrivate = memoize((variants) => {
+	if (DEV && variants.length === 0) throw new Error(`Attempt to use "asset" function without arguments`);
+	const map = {};
+	const extensions = [];
+	for (const v of variants) {
+		const e = getUrlFileExtension(v);
+		map[e] = v;
+		extensions.push(e);
+	}
+	const type = getType(extensions);
+	const getSource = once(() => {
+		const support = SUPPORT_MAPS[type];
+		for (const extension of extensions) if (extension in support) {
+			if (support[extension]) return map[extension];
+		} else return map[extension];
+		if (DEV) throw new Error(`No matching asset was found for ${variants.map((v) => `"${v}"`).join(", ")}`);
+		return "";
+	});
+	return {
+		get source() {
+			return getSource();
+		},
+		get type() {
+			return type;
+		},
+		id: generateRandomId()
+	};
+}, { getCacheKey: (variants) => variants.join("~") });
+/**
+* Memoizes and returns an asset selection object based on provided file variants.
+* The selected asset depends on the client's support for various formats.
+*
+* @param {...string} variants - A variable number of strings, each representing a potential asset file URL.
+* @returns {NovelyAsset} An object representing the selected asset with `source` and `type` properties.
+*
+* @throws {Error} If in DEV mode and no arguments are provided.
+* @example
+* ```
+* import { asset } from 'novely';
+*
+* // Passed first have higher priority
+* const classroom = asset(
+*   'classroom.avif',
+*   'classroom.webp',
+*   'classroom.jpeg'
+* );
+*
+* setTimeout(() => {
+*   console.log(classroom.source);
+* }, 100);
+* ```
+*/
+const asset = (...variants) => {
+	return assetPrivate(variants);
+};
+asset.image = (source) => {
+	if (assetPrivate.cache.has(source)) return assetPrivate.cache.get(source);
+	const asset = {
+		type: "image",
+		source,
+		id: generateRandomId()
+	};
+	assetPrivate.cache.set(source, asset);
+	return asset;
+};
+asset.audio = (source) => {
+	if (assetPrivate.cache.has(source)) return assetPrivate.cache.get(source);
+	const asset = {
+		type: "audio",
+		source,
+		id: generateRandomId()
+	};
+	assetPrivate.cache.set(source, asset);
+	return asset;
+};
+const unwrapAsset = (asset) => {
+	return isAsset(asset) ? asset.source : asset;
+};
+const unwrapAudioAsset = (asset) => {
+	if (DEV && isAsset(asset) && asset.type !== "audio") throw new Error("Attempt to use non-audio asset in audio action", { cause: asset });
+	return unwrapAsset(asset);
+};
+const unwrapImageAsset = (asset) => {
+	if (DEV && isAsset(asset) && asset.type !== "image") throw new Error("Attempt to use non-image asset in action that requires image assets", { cause: asset });
+	return unwrapAsset(asset);
+};
+
+//#endregion
+//#region src/utilities/actions-processing.ts
+const isExitImpossible = (path) => {
+	const blockStatements = path.filter(([item]) => isBlockStatement(item));
+	const blockExitStatements = path.filter(([item]) => isBlockExitStatement(item));
+	/**
+	* There were no blocks nor exits from blocks
+	*/
+	if (blockStatements.length === 0 && blockExitStatements.length === 0) return true;
+	/**
+	* There is block that can be exited
+	*/
+	if (blockStatements.length > blockExitStatements.length) return false;
+	return !blockExitStatements.every(([name], i) => name && name.startsWith(blockStatements[i][0]));
+};
+const createReferFunction = ({ story, onUnknownSceneHit }) => {
+	const refer = async (path) => {
+		/**
+		* Are we ready to return a value.
+		* We need to know are there any "unknown" scenes or not
+		*/
+		const { promise: ready, resolve: setReady } = Promise.withResolvers();
+		let current = story;
+		let precurrent = story;
+		const blocks = [];
+		const refer = async () => {
+			for (const [type, val] of path) if (type === "jump") {
+				if (!current[val]) {
+					setReady(true);
+					await onUnknownSceneHit(val);
+				}
+				if (DEV && !story[val]) throw new Error(`Attempt to jump to unknown scene "${val}"`);
+				if (DEV && story[val].length === 0) throw new Error(`Attempt to jump to empty scene "${val}"`);
+				precurrent = story;
+				current = current[val];
+			} else if (type === null) {
+				precurrent = current;
+				current = current[val];
+			} else if (type === "choice") {
+				blocks.push(precurrent);
+				current = current[val + 1][1];
+			} else if (type === "condition") {
+				blocks.push(precurrent);
+				current = current[2][val];
+			} else if (type === "block") {
+				blocks.push(precurrent);
+				current = story[val];
+			} else if (type === "block:exit" || type === "choice:exit" || type === "condition:exit") current = blocks.pop();
+			setReady(false);
+			return current;
+		};
+		const value = refer();
+		return {
+			found: await ready,
+			value
+		};
+	};
+	const referGuarded = async (path) => {
+		return await (await refer(path)).value;
+	};
+	return {
+		refer,
+		referGuarded
+	};
+};
+const exitPath = async ({ path, refer, onExitImpossible }) => {
+	const last = path.at(-1);
+	const ignore = [];
+	let wasExitImpossible = false;
+	/**
+	* - should be an array
+	* - first element is action name
+	*/
+	if (!isAction(await refer(path))) if (last && isNull(last[0]) && isNumber(last[1])) last[1]--;
+	else path.pop();
+	if (isExitImpossible(path)) {
+		const referred = await refer(path);
+		if (isAction(referred) && isSkippedDuringRestore(referred[0])) onExitImpossible?.();
+		wasExitImpossible = true;
+		return { exitImpossible: wasExitImpossible };
+	}
+	for (let i = path.length - 1; i > 0; i--) {
+		const [name] = path[i];
+		/**
+		* Remember already exited paths
+		*/
+		if (isBlockExitStatement(name)) ignore.push(name);
+		/**
+		* Ignore everything that we do not need there
+		*/
+		if (!isBlockStatement(name)) continue;
+		/**
+		* When we found an already exited path we remove it from the list
+		*/
+		if (ignore.at(-1)?.startsWith(name)) {
+			ignore.pop();
+			continue;
+		}
+		/**
+		* Exit from the path
+		*/
+		path.push([`${name}:exit`]);
+		const prev = findLastPathItemBeforeItemOfType(path.slice(0, i + 1), name);
+		/**
+		* When possible also go to the next action (or exit from one layer above)
+		*/
+		if (prev) path.push([null, prev[1] + 1]);
+		/**
+		* If we added an `[null, int]` but it points not to action, then
+		*
+		* - remove that item
+		* - close another block
+		*/
+		if (!isAction(await refer(path))) {
+			path.pop();
+			continue;
+		}
+		break;
+	}
+	return { exitImpossible: wasExitImpossible };
+};
+const nextPath = (path) => {
+	/**
+	* Last path element
+	*/
+	const last = path.at(-1);
+	if (last && (isNull(last[0]) || last[0] === "jump") && isNumber(last[1])) last[1]++;
+	else path.push([null, 0]);
+	return path;
+};
+const collectActionsBeforeBlockingAction = async ({ path, refer, clone }) => {
+	const collection = [];
+	let action = await refer(path);
+	while (true) {
+		if (action == void 0) {
+			const { exitImpossible } = await exitPath({
+				path,
+				refer
+			});
+			if (exitImpossible) break;
+		}
+		if (!action) break;
+		if (isBlockingAction(action)) {
+			const [name, ...props] = action;
+			if (name === "choice") {
+				const choiceProps = props;
+				for (let i = 0; i < choiceProps.length; i++) {
+					const branchContent = choiceProps[i];
+					/**
+					* This is a title
+					*/
+					if (!Array.isArray(branchContent)) continue;
+					const virtualPath = clone(path);
+					virtualPath.push(["choice", i], [null, 0]);
+					const innerActions = await collectActionsBeforeBlockingAction({
+						path: virtualPath,
+						refer,
+						clone
+					});
+					collection.push(...innerActions);
+				}
+			} else if (name === "condition") {
+				const conditionProps = props;
+				const conditions = Object.keys(conditionProps[1]);
+				for (const condition of conditions) {
+					const virtualPath = clone(path);
+					virtualPath.push(["condition", condition], [null, 0]);
+					const innerActions = await collectActionsBeforeBlockingAction({
+						path: virtualPath,
+						refer,
+						clone
+					});
+					collection.push(...innerActions);
+				}
+			}
+			break;
+		}
+		collection.push(action);
+		/**
+		* These special actions requires path change
+		*/
+		if (action[0] === "jump") path = [["jump", action[1]], [null, 0]];
+		else if (action[0] == "block") path.push(["block", action[1]], [null, 0]);
+		else nextPath(path);
+		action = await refer(path);
+	}
+	return collection;
+};
+const findLastPathItemBeforeItemOfType = (path, name) => {
+	return path.findLast(([_name, _value], i, array) => {
+		const next = array[i + 1];
+		return isNull(_name) && isNumber(_value) && next != null && next[0] === name;
+	});
+};
+const getOppositeAction = (action) => {
+	return {
+		showCharacter: "hideCharacter",
+		playSound: "stopSound",
+		playMusic: "stopMusic",
+		voice: "stopVoice"
+	}[action];
+};
+const getActionsFromPath = async ({ story, path, filter, referGuarded }) => {
+	/**
+	* Current item in the story
+	*/
+	let current = story;
+	/**
+	* Previous `current` value
+	*/
+	let precurrent;
+	/**
+	* Should we ignore some actions
+	*/
+	let ignoreNestedBefore = null;
+	/**
+	* Current item of type `[null, int]`
+	*/
+	let index = 0;
+	/**
+	* Skipped action that should be preserved
+	*/
+	let skipPreserve = void 0;
+	/**
+	* Actions that are either considered user action or skipped during restore process
+	*/
+	const skip = /* @__PURE__ */ new Set();
+	/**
+	* Cound of items of type `[null, int]`
+	*/
+	const max = path.reduce((acc, [type, val]) => {
+		if (isNull(type) && isNumber(val)) return acc + 1;
+		return acc;
+	}, 0);
+	const queue = [];
+	const blocks = [];
+	await referGuarded(path);
+	for (const [type, val] of path) if (type === "jump") {
+		precurrent = story;
+		current = current[val];
+	} else if (type === null) {
+		precurrent = current;
+		if (isNumber(val)) {
+			index++;
+			let startIndex = 0;
+			if (ignoreNestedBefore) {
+				const prev = findLastPathItemBeforeItemOfType(path.slice(0, index), ignoreNestedBefore);
+				if (prev) {
+					startIndex = prev[1];
+					ignoreNestedBefore = null;
+				}
+			}
+			/**
+			* Запустим все экшены которые идут в `[null, int]` от `0` до `int`
+			* Почему-то потребовалось изменить `<` на `<=`, чтобы последний action попадал сюда
+			*/
+			for (let i = startIndex; i <= val; i++) {
+				const item = current[i];
+				/**
+				* In case of broken save at least not throw
+				* But is should not happen
+				*/
+				if (!isAction(item)) continue;
+				const [action] = item;
+				const last = index === max && i === val;
+				const shouldSkip = isSkippedDuringRestore(action) || isUserRequiredAction(item);
+				if (shouldSkip) skip.add(item);
+				if (shouldSkip && last) skipPreserve = item;
+				if (filter && shouldSkip && !last) continue;
+				else queue.push(item);
+			}
+		}
+		current = current[val];
+	} else if (type === "choice") {
+		blocks.push(precurrent);
+		current = current[val + 1][1];
+	} else if (type === "condition") {
+		blocks.push(precurrent);
+		current = current[2][val];
+	} else if (type === "block") {
+		blocks.push(precurrent);
+		current = story[val];
+	} else if (type === "block:exit" || type === "choice:exit" || type === "condition:exit") {
+		current = blocks.pop();
+		ignoreNestedBefore = type.slice(0, -5);
+	}
+	return {
+		queue,
+		skip,
+		skipPreserve
+	};
+};
+const createQueueProcessor = (queue, options) => {
+	const processedQueue = [];
+	const keep = /* @__PURE__ */ new Set();
+	const characters = /* @__PURE__ */ new Set();
+	const audio = {
+		music: /* @__PURE__ */ new Set(),
+		sounds: /* @__PURE__ */ new Set()
+	};
+	/**
+	* Get the next actions array.
+	*/
+	const next = (i) => queue.slice(i + 1);
+	for (const [i, item] of queue.entries()) {
+		const [action, ...params] = item;
+		if (options.skip.has(item) && item !== options.skipPreserve) continue;
+		keep.add(action);
+		if (action === "function" || action === "custom") {
+			if (action === "custom") {
+				const fn = params[0];
+				if (fn.callOnlyLatest) {
+					if (next(i).some(([name, func]) => {
+						if (name !== "custom") return;
+						const isIdenticalId = Boolean(func.id && fn.id && func.id === fn.id);
+						const isIdenticalByReference = func === fn;
+						const isIdenticalByCode = String(func) === String(fn);
+						return isIdenticalId || isIdenticalByReference || isIdenticalByCode;
+					})) continue;
+				} else if (fn.skipOnRestore) {
+					if (fn.skipOnRestore(next(i))) continue;
+				}
+			}
+			processedQueue.push(item);
+		} else if (action === "playSound") {
+			const closing = getOppositeAction(action);
+			if (next(i).some((item) => {
+				if (isUserRequiredAction(item) || isSkippedDuringRestore(item[0])) return true;
+				const [_action, target] = item;
+				if (target !== params[0]) return false;
+				return _action === closing || _action === action;
+			})) continue;
+			audio.sounds.add(unwrapAsset(params[0]));
+			processedQueue.push(item);
+		} else if (action === "showCharacter" || action === "playMusic" || action === "voice") {
+			const closing = getOppositeAction(action);
+			if (next(i).some(([_action, target]) => {
+				if (target !== params[0] && action !== "voice") return false;
+				/**
+				* It either will be closed OR same action will be ran again
+				*/
+				return action === "playMusic" && _action === "pauseMusic" || _action === closing || _action === action;
+			})) continue;
+			/**
+			* Actually, we do not need check above to add there things to keep because if something was hidden already we could not keep it visible
+			*/
+			if (action === "showCharacter") characters.add(params[0]);
+			else if (action === "playMusic") audio.music.add(unwrapAsset(params[0]));
+			processedQueue.push(item);
+		} else if (action === "showBackground" || action === "preload") {
+			if (next(i).some(([_action]) => action === _action)) continue;
+			processedQueue.push(item);
+		} else if (action === "animateCharacter") {
+			if (next(i).some(([_action, character], j, array) => {
+				if (action === _action && character === params[0]) return true;
+				const next = array.slice(j);
+				const characterWillAnimate = next.some(([__action, __character]) => action === __action);
+				const hasBlockingActions = next.some((item) => options.skip.has(item));
+				const differentCharacterWillAnimate = !hasBlockingActions && next.some(([__action, __character]) => __action === action && __character !== params[0]);
+				return characterWillAnimate && hasBlockingActions || differentCharacterWillAnimate;
+			})) continue;
+			processedQueue.push(item);
+		} else processedQueue.push(item);
+	}
+	const run = async (match) => {
+		for (const item of processedQueue) {
+			const result = match(item);
+			if (isPromise(result)) await result;
+		}
+		processedQueue.length = 0;
+	};
+	return {
+		run,
+		keep: {
+			keep,
+			characters,
+			audio
+		}
+	};
+};
+
+//#endregion
+//#region src/utilities/controlled-promise.ts
+const createControlledPromise = () => {
+	const object = {
+		resolve: null,
+		reject: null,
+		promise: null,
+		cancel: null
+	};
+	const init = () => {
+		object.promise = new Promise((resolve, reject) => {
+			object.reject = reject;
+			object.resolve = (value) => {
+				resolve({
+					cancelled: false,
+					value
+				});
+			};
+			object.cancel = () => {
+				resolve({
+					cancelled: true,
+					value: null
+				});
+				init();
+			};
+		});
+	};
+	return init(), object;
+};
+
+//#endregion
+//#region src/utilities/resources.ts
+const getUrlFileExtension = (address) => {
+	try {
+		const { pathname } = new URL(address, location.href);
+		/**
+		* By using pathname we remove search params from URL, but some things are still preserved
+		*
+		* Imagine pathname like `image.png!private:1230`
+		*/
+		return pathname.split(".").at(-1).split("!")[0].split(":")[0];
+	} catch (error) {
+		if (DEV) console.error(new Error(`Could not construct URL "${address}".`, { cause: error }));
+		return "";
+	}
+};
+const fetchContentType = async (url, request) => {
+	try {
+		return (await request(url, { method: "HEAD" })).headers.get("Content-Type") || "";
+	} catch (error) {
+		if (DEV) console.error(new Error(`Failed to fetch file at "${url}"`, { cause: error }));
+		return "";
+	}
+};
+const getResourseType = memoize(async ({ url, request }) => {
+	const extension = getUrlFileExtension(url);
+	if (HOWLER_SUPPORTED_FILE_FORMATS.has(extension)) return "audio";
+	if (SUPPORTED_IMAGE_FILE_FORMATS.has(extension)) return "image";
+	/**
+	* If checks above didn't worked we will fetch content type
+	* This might not work because of CORS
+	*/
+	const contentType = await fetchContentType(url, request);
+	if (contentType.includes("audio")) return "audio";
+	if (contentType.includes("image")) return "image";
+	return "other";
+}, { getCacheKey: ({ url }) => url });
+
+//#endregion
+//#region src/utilities/stack.ts
+const getStack = memoize((_) => {
+	return [];
+}, {
+	cache: STACK_MAP,
+	getCacheKey: (ctx) => ctx.id
+});
+const createUseStackFunction = (renderer) => {
+	const useStack = (context) => {
+		const ctx = typeof context === "string" ? renderer.getContext(context) : context;
+		const stack = getStack(ctx);
+		return {
+			get previous() {
+				return stack.previous;
+			},
+			get value() {
+				return stack.at(-1);
+			},
+			set value(value) {
+				stack[stack.length - 1] = value;
+			},
+			back() {
+				stack.previous = stack.length > 1 ? stack.pop() : this.value;
+				ctx.meta.goingBack = true;
+			},
+			push(value) {
+				stack.push(value);
+			},
+			clear() {
+				stack.previous = void 0;
+				stack.length = 0;
+				stack.length = 1;
+			}
+		};
+	};
+	return useStack;
+};
+
+//#endregion
+//#region src/utilities/story.ts
+const flatActions = (item) => {
+	return item.flatMap((data) => {
+		const type = data[0];
+		/**
+		* This is not just an action like `['name', ...arguments]`, but an array of actions
+		*/
+		if (Array.isArray(type)) return flatActions(data);
+		return [data];
+	});
+};
+/**
+* Transforms `(ValidAction | ValidAction[])[]` to `ValidAction[]`. Mutates provided `Story`
+*/
+const flatStory = (story) => {
+	for (const key in story) story[key] = flatActions(story[key]);
+	return story;
+};
+
+//#endregion
+//#region src/utilities/internationalization.ts
+const getLanguage = (languages) => {
+	let { language } = navigator;
+	if (languages.includes(language)) return language;
+	else if (languages.includes(language = language.slice(0, 2))) return language;
+	else if (language = languages.find((value) => navigator.languages.includes(value))) return language;
+	/**
+	* We'v checked the `en-GB` format, `en` format, and maybe any second languages, but there were no matches
+	*/
+	return languages[0];
+};
+const getIntlLanguageDisplayName = memoize((lang) => {
+	/**
+	* When using Intl fails we just return language key.
+	*/
+	try {
+		return new Intl.DisplayNames([lang], { type: "language" }).of(lang) || lang;
+	} catch {
+		return lang;
+	}
+});
+/**
+* Capitalizes the string
+* @param str String without emojis or complex graphemes
+*/
+const capitalize = (str) => {
+	return str[0].toUpperCase() + str.slice(1);
+};
+
+//#endregion
+//#region src/utilities/noop.ts
+const noop = () => {};
+
+//#endregion
+//#region src/utilities/store.ts
+const getLanguageFromStore = (store) => {
+	return store.get().meta[0];
+};
+const getVolumeFromStore = (store) => {
+	const { meta } = store.get();
+	return {
+		music: meta[2],
+		sound: meta[3],
+		voice: meta[4]
+	};
+};
+
+//#endregion
+//#region src/utilities/array.ts
+const mapSet = (set, fn) => {
+	return [...set].map(fn);
+};
+const toArray = (target) => {
+	return Array.isArray(target) ? target : [target];
+};
+
+//#endregion
+//#region src/utilities/else.ts
+const getCharactersData = (characters) => {
+	const mapped = Object.entries(characters).map(([key, value]) => [key, {
+		name: value.name,
+		emotions: Object.keys(value.emotions)
+	}]);
+	return Object.fromEntries(mapped);
+};
+
+//#endregion
+//#region src/store.ts
+const store = (current, subscribers = /* @__PURE__ */ new Set()) => {
+	const subscribe = (cb) => {
+		subscribers.add(cb), cb(current);
+		return () => {
+			subscribers.delete(cb);
+		};
+	};
+	const push = (value) => {
+		for (const cb of subscribers) cb(value);
+	};
+	const update = (fn) => {
+		push(current = fn(current));
+	};
+	const set = (val) => {
+		update(() => val);
+	};
+	const get = () => {
+		return current;
+	};
+	return {
+		subscribe,
+		update,
+		set,
+		get
+	};
+};
+const derive = (input, map) => {
+	return {
+		get: () => map(input.get()),
+		subscribe: (subscriber) => {
+			return input.subscribe((value) => {
+				return subscriber(map(value));
+			});
+		}
+	};
+};
+const immutable = (value) => {
+	return {
+		get: () => value,
+		subscribe: (subscriber) => {
+			subscriber(value);
+			return noop;
+		}
+	};
+};
+
+//#endregion
+//#region src/custom-action.ts
+const createCustomActionNode = (id) => {
+	const div = document.createElement("div");
+	div.setAttribute("data-id", id);
+	return div;
+};
+const getCustomActionHolder = (ctx, fn) => {
+	const cached = CUSTOM_ACTION_MAP.get(ctx.id + fn.key);
+	if (cached) return cached;
+	const holder = {
+		node: null,
+		fn,
+		localData: {}
+	};
+	CUSTOM_ACTION_MAP.set(ctx.id + fn.key, holder);
+	return holder;
+};
+const getCustomActionInstances = (ctx) => {
+	const existing = CUSTOM_ACTION_INSTANCES_MAP.get(ctx.id);
+	if (existing) return existing;
+	const array = [];
+	CUSTOM_ACTION_INSTANCES_MAP.set(ctx.id, array);
+	return array;
+};
+const cleanInstance = ({ list }) => {
+	while (list.length) try {
+		list.pop()();
+	} catch (e) {
+		console.error(e);
+	}
+};
+const handleCustomAction = (ctx, fn, { lang, state, setMountElement, remove: renderersRemove, getStack, templateReplace, paused, ticker, request }) => {
+	const holder = getCustomActionHolder(ctx, fn);
+	const instances = getCustomActionInstances(ctx);
+	const cleanupNode = () => {
+		if (!instances.some((item) => item.fn.id === fn.id && item.fn.key === fn.key)) {
+			holder.node = null;
+			setMountElement(null);
+		}
+	};
+	const dispose = () => {
+		if (instance.disposed) return;
+		ticker.detach();
+		instance.onBack = noop;
+		instance.onForward = noop;
+		instance.disposed = true;
+	};
+	const instance = {
+		fn,
+		disposed: false,
+		list: [dispose],
+		node: cleanupNode,
+		onBack: noop,
+		onForward: noop
+	};
+	instances.push(instance);
+	const getDomNodes = (insert = true) => {
+		if (holder.node || !insert) {
+			setMountElement(holder.node);
+			return {
+				element: holder.node,
+				root: ctx.root
+			};
+		}
+		holder.node = insert ? createCustomActionNode(fn.key) : null;
+		setMountElement(holder.node);
+		return {
+			element: holder.node,
+			root: ctx.root
+		};
+	};
+	const clear = (func) => {
+		instance.list.push(once(func));
+	};
+	const data = (updatedData) => {
+		if (updatedData) return holder.localData = updatedData;
+		return holder.localData;
+	};
+	const remove = () => {
+		cleanInstance(instance);
+		holder.node = null;
+		setMountElement(null);
+		renderersRemove();
+	};
+	const stack = getStack(ctx);
+	const getSave = () => {
+		return stack.value;
+	};
+	return fn({
+		flags: ctx.meta,
+		lang,
+		state,
+		data,
+		dataAtKey: (key) => CUSTOM_ACTION_MAP.get(ctx.id + key)?.localData || null,
+		templateReplace,
+		clear,
+		remove,
+		rendererContext: ctx,
+		getDomNodes,
+		getSave,
+		contextKey: ctx.id,
+		paused: ctx.meta.preview ? immutable(false) : paused,
+		ticker,
+		request,
+		onBack: (fn) => {
+			instance.onBack = fn;
+		},
+		onForward: (fn) => {
+			instance.onForward = fn;
+		}
+	});
+};
+
+//#endregion
+//#region src/preloading.ts
+const ACTION_NAME_TO_VOLUME_MAP = {
+	playMusic: "music",
+	playSound: "sound",
+	voice: "voice"
+};
+/**
+* Adds asset to `ASSETS_TO_PRELOAD` firstly checking if is was already preloaded
+*/
+const enqueueAssetForPreloading = (asset) => {
+	if (!PRELOADED_ASSETS.has(asset)) ASSETS_TO_PRELOAD.add(asset);
+};
+/**
+* Preloads assets
+*/
+const handleAssetsPreloading = async ({ request, limiter, preloadAudioBlocking, preloadImageBlocking }) => {
+	const list = mapSet(ASSETS_TO_PRELOAD, (asset) => {
+		return limiter(async () => {
+			switch (await getResourseType({
+				url: asset,
+				request
+			})) {
+				case "audio":
+					await preloadAudioBlocking(asset);
+					break;
+				case "image":
+					await preloadImageBlocking(asset);
+					break;
+			}
+			ASSETS_TO_PRELOAD.delete(asset);
+			PRELOADED_ASSETS.add(asset);
+		});
+	});
+	/**
+	* `allSettled` is used because even if error happens game should run
+	*
+	* Ideally, there could be a notification for player, maybe developer could be also notified
+	* But I don't think it's really needed
+	*/
+	await Promise.allSettled(list);
+	ASSETS_TO_PRELOAD.clear();
+};
+const huntAssets = async ({ volume, lang, characters, action, props, handle, request }) => {
+	if (action === "showBackground") {
+		if (isAsset(props[0]) || isString(props[0])) {
+			handle(unwrapImageAsset(props[0]));
+			return;
+		}
+		if (props[0] && typeof props[0] === "object") for (const value of Object.values(props[0])) if (isAsset(value)) handle(unwrapImageAsset(value));
+		else handle(value);
+		return;
+	}
+	const getVolumeFor = (action) => {
+		if (action in ACTION_NAME_TO_VOLUME_MAP) return volume[ACTION_NAME_TO_VOLUME_MAP[action]];
+		return 0;
+	};
+	/**
+	* Here "stop" action also matches condition, but because `ASSETS_TO_PRELOAD` is a Set, there is no problem
+	*/
+	if (isAudioAction(action) && isString(props[0])) {
+		if (getVolumeFor(action) > 0) handle(unwrapAudioAsset(props[0]));
+		return;
+	}
+	if (action === "voice" && typeof props[0] === "object") {
+		/**
+		* Early return in case of disabled voices
+		*/
+		if (getVolumeFor("voice") == 0) return;
+		for (const [language, value] of Object.entries(props[0])) if (language === lang)
+ /**
+		* todo: decide how to make language comparison (maybe use some function)
+		*
+		* We can use en-US for both en-US and en-GB. Same thing applies to `dialog` and `text` action.
+		* Maybe voice over language can be selected separately
+		*/
+		value && handle(unwrapAudioAsset(value));
+		return;
+	}
+	/**
+	* Load characters
+	*/
+	if (action === "showCharacter" && isString(props[0]) && isString(props[1])) {
+		const images = toArray(characters[props[0]].emotions[props[1]]);
+		for (const asset of images) handle(unwrapImageAsset(asset));
+		return;
+	}
+	/**
+	* Custom action assets
+	*/
+	if (action === "custom" && props[0].assets) {
+		const assets = props[0].assets;
+		let resolved = [];
+		if (typeof assets === "function") {
+			resolved = await Promise.race([assets({ request }), new Promise((resolve) => setTimeout(resolve, 250, []))]);
+			Object.defineProperty(props[0], "assets", {
+				value: async () => resolved,
+				writable: false
+			});
+		} else resolved = assets;
+		for (const asset of resolved) isAsset(asset) ? handle(asset.source) : handle(asset);
+		return;
+	}
+	if (action === "choice") for (let i = 1; i < props.length; i++) {
+		const data = props[i];
+		if (Array.isArray(data)) {
+			if (data[5]) handle(unwrapImageAsset(data[5]));
+		}
+	}
+};
+
+//#endregion
+//#region src/storage.ts
+/**
+* Stores data in localStorage
+*/
+const storageAdapterLocal = ({ key }) => {
+	return {
+		async get() {
+			const fallback = {
+				saves: [],
+				data: {},
+				meta: []
+			};
+			try {
+				const value = localStorage.getItem(key);
+				return value ? JSON.parse(value) : fallback;
+			} catch {
+				return fallback;
+			}
+		},
+		async set(data) {
+			try {
+				localStorage.setItem(key, JSON.stringify(data));
+			} catch {}
+		}
+	};
+};
+
+//#endregion
+//#region src/translation.ts
+const RGX = /{{(.*?)}}/g;
+const split = (input, delimeters) => {
+	const output = [];
+	for (const delimeter of delimeters) {
+		if (!input) break;
+		const [start, end] = input.split(delimeter, 2);
+		output.push(start);
+		input = end;
+	}
+	output.push(input);
+	return output;
+};
+/**
+* Turns any allowed content into string
+* @param c Content
+*/
+const flattenAllowedContent = (c, state) => {
+	if (Array.isArray(c)) return c.map((item) => flattenAllowedContent(item, state)).join("<br>");
+	if (typeof c === "function") return flattenAllowedContent(c(state), state);
+	return c;
+};
+const replace = (input, data, pluralization, actions, pr) => {
+	return input.replaceAll(RGX, (x, key, y) => {
+		x = 0;
+		y = data;
+		const [pathstr, plural, action] = split(key.trim(), ["@", "%"]);
+		if (!pathstr) return "";
+		const path = pathstr.split(".");
+		while (y && x < path.length) y = y[path[x++]];
+		if (plural && pluralization && y && pr) y = pluralization[plural][pr.select(y)];
+		const actionHandler = actions && action ? actions[action] : void 0;
+		if (actionHandler) y = actionHandler(y);
+		return y == null ? "" : y;
+	});
+};
+
+//#endregion
+//#region src/utilities/actions.ts
+/**
+* In this case actions that get overwritten with another action
+*/
+const VIRTUAL_ACTIONS = ["say"];
+const buildActionObject = ({ rendererActions, nativeActions, characters }) => {
+	const allActions = [...nativeActions, ...VIRTUAL_ACTIONS];
+	const object = { ...rendererActions };
+	for (let action of allActions) object[action] = (...props) => {
+		if (action === "say") {
+			action = "dialog";
+			const [character] = props;
+			if (DEV && !characters[character]) throw new Error(`Attempt to call Say action with unknown character "${character}"`);
+		} else if (action === "choice") if (props.slice(1).every((choice) => !Array.isArray(choice))) for (let i = 1; i < props.length; i++) {
+			const choice = props[i];
+			props[i] = [
+				choice.title,
+				flatActions(choice.children),
+				choice.active,
+				choice.visible,
+				choice.onSelect,
+				choice.image
+			];
+		}
+		else for (let i = 1; i < props.length; i++) {
+			const choice = props[i];
+			if (Array.isArray(choice)) choice[1] = flatActions(choice[1]);
+		}
+		else if (action === "condition") {
+			const actions = props[1];
+			for (const key in actions) actions[key] = flatActions(actions[key]);
+		}
+		return [action, ...props];
+	};
+	return object;
+};
+
+//#endregion
+//#region src/utilities/dialog-overview.ts
+const getDialogOverview = async function() {
+	/**
+	* Dialog Overview is possible only in main context
+	*/
+	const { value: save } = this.getStack();
+	const stateSnapshots = save[3];
+	/**
+	* Easy mode
+	*/
+	if (stateSnapshots.length == 0) return [];
+	const { queue } = await getActionsFromPath({
+		story: this.story,
+		path: save[0],
+		filter: false,
+		referGuarded: this.referGuarded
+	});
+	const lang = this.getLanguage();
+	const dialogItems = [];
+	/**
+	* For every available state snapshot find dialog corresponding to it
+	*/
+	for (let p = 0, a = stateSnapshots.length, i = queue.length - 1; a > 0 && i > 0; i--) {
+		const action = queue[i];
+		if (action[0] === "dialog") {
+			const [_, name, text] = action;
+			let voice = void 0;
+			/**
+			* Search for the most recent `voice` action before current dialog
+			*/
+			for (let j = i - 1; j > p && j > 0; j--) {
+				const action = queue[j];
+				if (isUserRequiredAction(action) || isSkippedDuringRestore(action[0])) break;
+				if (action[0] === "stopVoice") break;
+				if (action[0] === "voice") {
+					voice = action[1];
+					break;
+				}
+			}
+			dialogItems.push({
+				name,
+				text,
+				voice
+			});
+			p = i;
+			a--;
+		}
+	}
+	return dialogItems.reverse().map(({ name, text, voice }, i) => {
+		const state = stateSnapshots[i];
+		const audioSource = isString(voice) ? voice : isAsset(voice) ? voice : voice == void 0 ? voice : voice[lang];
+		name = name ? this.getCharacterName(name) : "";
+		return {
+			name: this.templateReplace(name, state),
+			text: this.templateReplace(text, state),
+			voice: audioSource ? unwrapAudioAsset(audioSource) : ""
+		};
+	});
+};
+
+//#endregion
+//#region src/utilities/document.ts
+const setDocumentLanguage = (language) => {
+	document.documentElement.lang = language;
+};
+
+//#endregion
+//#region src/ticker.ts
+var Ticker = class {
+	listeners = /* @__PURE__ */ new Set();
+	running = false;
+	_factory;
+	constructor(factory) {
+		this._factory = factory;
+	}
+	get deltaTime() {
+		return this._factory.deltaTime;
+	}
+	get lastTime() {
+		return this._factory.lastTime;
+	}
+	add(cb) {
+		this.listeners.add(cb);
+		if (this.listeners.size === 1) this._factory.check(true);
+		return () => {
+			this.remove(cb);
+		};
+	}
+	remove(cb) {
+		this.listeners.delete(cb);
+		if (this.listeners.size === 0) this._factory.check(false);
+	}
+	start = () => {
+		this.running = true;
+		if (this.listeners.size > 0) this._factory.check(true);
+	};
+	stop = () => {
+		this.running = false;
+	};
+	detach = () => {
+		this.listeners.clear();
+		this.stop();
+		this._factory.detach(this);
+	};
+};
+var TickerFactory = class {
+	_children = /* @__PURE__ */ new Set();
+	_raf = -1;
+	_running = false;
+	_unsubscribe;
+	deltaTime = 0;
+	lastTime = performance.now();
+	constructor(paused) {
+		this._unsubscribe = paused.subscribe((paused) => {
+			if (paused) this.stop();
+			else if (Array.from(this._children).some((ticker) => ticker.running && ticker.listeners.size > 0)) this.start();
+		});
+	}
+	start() {
+		if (this._running) return;
+		cancelAnimationFrame(this._raf);
+		this.lastTime = performance.now();
+		this._running = true;
+		this._raf = requestAnimationFrame(this.update);
+	}
+	stop() {
+		cancelAnimationFrame(this._raf);
+		this._running = false;
+		this._raf = -1;
+	}
+	fork() {
+		const ticker = new Ticker(this);
+		this._children.add(ticker);
+		return ticker;
+	}
+	check(positive) {
+		if (positive) this.start();
+		else if (Array.from(this._children).every((ticker) => !ticker.running || ticker.listeners.size === 0)) this.stop();
+	}
+	destroy() {
+		this._unsubscribe();
+		this._children.forEach((child) => child.detach());
+	}
+	detach(ticker) {
+		this._children.delete(ticker);
+		this.check(false);
+	}
+	update = (currentTime) => {
+		this.deltaTime = currentTime - this.lastTime;
+		this._children.forEach((ticker) => {
+			if (ticker.running) ticker.listeners.forEach((tick) => {
+				tick(ticker);
+			});
+		});
+		if (!this._running) return;
+		this.lastTime = currentTime;
+		this._raf = requestAnimationFrame(this.update);
+	};
+};
+
+//#endregion
+//#region src/novely.ts
+const novely = ({ characters, characterAssetSizes = {}, defaultEmotions = {}, storage = storageAdapterLocal({ key: "novely-game-storage" }), storageDelay = Promise.resolve(), renderer: createRenderer, initialScreen = "mainmenu", translation, state: defaultState = {}, data: defaultData = {}, autosaves = true, migrations = [], throttleTimeout = 850, getLanguage: getLanguage$1 = getLanguage, overrideLanguage = false, askBeforeExit = true, preloadAssets = "automatic", parallelAssetsDownloadLimit = 15, fetch: request = fetch, cloneFunction: clone = klona, saveOnUnload = true, startKey = "start", defaultTypewriterSpeed = DEFAULT_TYPEWRITER_SPEED, storyOptions = { mode: "static" }, onLanguageChange }) => {
+	const languages = Object.keys(translation);
+	const limitScript = pLimit(1);
+	const limitAssetsDownload = pLimit(parallelAssetsDownloadLimit);
+	const story = {};
+	const times = /* @__PURE__ */ new Set();
+	const dataLoaded = createControlledPromise();
+	let initialScreenWasShown = false;
+	let destroyed = false;
+	if (storyOptions.mode === "dynamic") storyOptions.preloadSaves ??= 4;
+	const storyLoad = storyOptions.mode === "static" ? noop : storyOptions.load;
+	const onUnknownSceneHit = memoize(async (scene) => {
+		const part = await storyLoad(scene);
+		if (part) await script(part);
+	});
+	/**
+	* Saves timestamps created in this session
+	*/
+	const intime = (value) => {
+		return times.add(value), value;
+	};
+	const scriptBase = async (part) => {
+		if (destroyed) return;
+		Object.assign(story, flatStory(part));
+		if (!initialScreenWasShown) renderer.ui.showLoading();
+		await dataLoaded.promise;
+		renderer.ui.hideLoading();
+		if (!initialScreenWasShown) {
+			initialScreenWasShown = true;
+			if (initialScreen === "game") restore(void 0);
+			else renderer.ui.showScreen(initialScreen);
+		}
+	};
+	/**
+	* Setup your story here
+	*
+	* Call more than once to merge different story parts
+	*
+	* @example
+	*
+	* ```js
+	* engine.script({
+	*  start: [action.jump('another-part')]
+	* })
+	*
+	* engine.script({
+	*  'another-part': []
+	* })
+	* ```
+	*/
+	const script = (part) => {
+		return limitScript(() => scriptBase(part));
+	};
+	const getDefaultSave = (state) => {
+		return [
+			[["jump", startKey], [null, 0]],
+			state,
+			[intime(Date.now()), "auto"],
+			[]
+		];
+	};
+	/**
+	* Calls `getLanguage`, passes needed arguments
+	* @returns language
+	*/
+	const getLanguageWithoutParameters = () => {
+		const language = getLanguage$1(languages, getLanguage);
+		if (languages.includes(language)) {
+			setDocumentLanguage(language);
+			return language;
+		}
+		if (DEV) throw new Error(`Attempt to use unsupported language "${language}". Supported languages: ${languages.join(", ")}.`);
+		throw 0;
+	};
+	const storageData = store({
+		saves: [],
+		data: clone(defaultData),
+		meta: [
+			getLanguageWithoutParameters(),
+			DEFAULT_TYPEWRITER_SPEED,
+			1,
+			1,
+			1
+		]
+	});
+	const coreData = store({
+		dataLoaded: false,
+		paused: false,
+		focused: document.visibilityState === "visible"
+	});
+	const paused = derive(coreData, (s) => s.paused || !s.focused);
+	const onDataLoadedPromise = async ({ cancelled }) => {
+		/**
+		* Promise cancelled? Re-subscribe
+		*/
+		if (cancelled) {
+			dataLoaded.promise.then(onDataLoadedPromise);
+			return;
+		}
+		const preload = () => {
+			const sliced = [...storageData.get().saves].reverse().slice(0, storyOptions.mode === "dynamic" ? storyOptions.preloadSaves : 0);
+			for (const [path] of sliced) referGuarded(path);
+		};
+		preload();
+		/**
+		* When promise is resolved data is marked loaded
+		*/
+		coreData.update((data) => {
+			data.dataLoaded = true;
+			return data;
+		});
+	};
+	dataLoaded.promise.then(onDataLoadedPromise);
+	const onStorageDataChange = (value) => {
+		if (!coreData.get().dataLoaded) return;
+		const data = clone(value);
+		/**
+		* Empty out data snapshots
+		*/
+		for (const save of data.saves) save[3] = [];
+		storage.set(data);
+	};
+	/**
+	* Short one is used in conditions like `beforeunload` when waiting for too long is not a case
+	* Another one relies on short one to prevent double saving
+	*/
+	const throttledShortOnStorageDataChange = throttle(() => onStorageDataChange(storageData.get()), 10);
+	const throttledOnStorageDataChange = throttle(throttledShortOnStorageDataChange, throttleTimeout);
+	storageData.subscribe(throttledOnStorageDataChange);
+	if (saveOnUnload === true || saveOnUnload === "prod" && !DEV) addEventListener("beforeunload", throttledShortOnStorageDataChange);
+	const getStoredData = async () => {
+		let stored = await storage.get();
+		for (const migration of migrations) {
+			stored = migration(stored);
+			if (DEV && !stored) throw new Error("Migrations should return a value.");
+		}
+		if (overrideLanguage || !stored.meta[0]) stored.meta[0] = getLanguageWithoutParameters();
+		/**
+		* Default `localStorageStorage` returns empty array
+		*/
+		stored.meta[1] ||= defaultTypewriterSpeed;
+		/**
+		* Sound Volumes
+		*/
+		stored.meta[2] ??= 1;
+		stored.meta[3] ??= 1;
+		stored.meta[4] ??= 1;
+		/**
+		* When data is empty replace it with `defaultData`
+		* It also might be empty (default to empty)
+		*/
+		if (isEmpty(stored.data)) stored.data = defaultData;
+		/**
+		* Now the next store updates will entail saving via storage.set
+		*/
+		dataLoaded.resolve();
+		storageData.set(stored);
+	};
+	/**
+	* By default this is resolved immediately, but also can be delayed.
+	* I.e. storage has not loaded yet
+	*/
+	storageDelay.then(getStoredData);
+	const initial = getDefaultSave(clone(defaultState));
+	const save = (type) => {
+		if (!coreData.get().dataLoaded) return;
+		/**
+		* When autosaves diabled just return
+		*/
+		if (!autosaves && type === "auto") return;
+		const current = clone(useStack(MAIN_CONTEXT_KEY).value);
+		storageData.update((prev) => {
+			const replace = () => {
+				prev.saves[prev.saves.length - 1] = current;
+				return prev;
+			};
+			const add = () => {
+				prev.saves.push(current);
+				return prev;
+			};
+			/**
+			* Get latest
+			*/
+			const last = prev.saves.at(-1);
+			/**
+			* We cannot compare anything here, thus just reutrn
+			*/
+			if (!last) return add();
+			/**
+			* Update type and time information
+			*/
+			current[2][0] = intime(Date.now());
+			current[2][1] = type;
+			/**
+			* Empty out state snapshots
+			*/
+			current[3] = [];
+			const isIdentical = dequal(last[0], current[0]) && dequal(last[1], current[1]);
+			const isLastMadeInCurrentSession = times.has(last[2][0]);
+			/**
+			* Even if override is false, we will replace auto save with manual, because they are the same thing basically
+			*/
+			if (isLastMadeInCurrentSession && last[2][1] === "auto" && type === "manual") return replace();
+			/**
+			* Player has made a manual save, novely decided to make an auto save
+			* But it is identical to previously created manual save so completely not wanted
+			*/
+			if (last[2][1] === "manual" && type === "auto" && isIdentical) return prev;
+			if (isLastMadeInCurrentSession && last[2][1] === "auto" && type === "auto") return replace();
+			return add();
+		});
+	};
+	const newGame = () => {
+		if (!coreData.get().dataLoaded) return;
+		const save = getDefaultSave(clone(defaultState));
+		/**
+		* Initial save is automatic, and should be ignored when autosaves is turned off
+		*/
+		if (autosaves) storageData.update((prev) => {
+			return prev.saves.push(save), prev;
+		});
+		const context = renderer.getContext(MAIN_CONTEXT_KEY);
+		const stack = useStack(context);
+		stack.value = save;
+		context.meta.restoring = context.meta.goingBack = false;
+		renderer.ui.showScreen("game");
+		render(context);
+	};
+	/**
+	* Set's the save and restores onto it
+	*/
+	const set = (save, ctx) => {
+		const stack = useStack(ctx || "$MAIN");
+		stack.value = save;
+		return restore(save);
+	};
+	let interacted = 0;
+	/**
+	* Restore save or if none is passed then look for latest save, if there is no saves will create a new save
+	*/
+	const restore = async (save) => {
+		if (isEmpty(story)) {
+			if (DEV) throw new Error("Story is empty. You should call an `enine.script` function [https://novely.pages.dev/guide/story.html]");
+			return;
+		}
+		if (!coreData.get().dataLoaded) return;
+		let latest = save || storageData.get().saves.at(-1);
+		/**
+		* When there is no save, make a new save
+		*/
+		if (!latest) {
+			latest = clone(initial);
+			storageData.update((prev) => {
+				prev.saves.push(latest);
+				return prev;
+			});
+		}
+		const context = renderer.getContext(MAIN_CONTEXT_KEY);
+		const stack = useStack(context);
+		context.meta.restoring = true;
+		const previous = stack.previous;
+		const [path] = stack.value = latest;
+		renderer.ui.showScreen("game");
+		const { found } = await refer(path);
+		if (found) context.loading(true);
+		const { queue, skip, skipPreserve } = await getActionsFromPath({
+			story,
+			path,
+			filter: false,
+			referGuarded
+		});
+		const instances = getCustomActionInstances(context);
+		if (previous) {
+			const { queue: prevQueue } = await getActionsFromPath({
+				story,
+				path: previous[0],
+				filter: false,
+				referGuarded
+			});
+			const futures = [];
+			const end = previous[0][0][1] !== path[0][1] ? 0 : queue.length - 1;
+			for (let i = prevQueue.length - 1; i >= end; i--) {
+				const [action, fn] = prevQueue[i];
+				if (action === "custom") futures.push(fn);
+			}
+			futures.reverse();
+			const nodeCleanup = /* @__PURE__ */ new Set();
+			for (const future of futures) inner: for (let i = instances.length - 1; i >= 0; i--) {
+				const instance = instances[i];
+				if (future === instance.fn) {
+					cleanInstance(instance);
+					nodeCleanup.add(instance.node);
+					instances.splice(i, 1);
+					break inner;
+				}
+			}
+			nodeCleanup.forEach((f) => f());
+			for (const instance of instances.filter((i) => !i.disposed)) instance.onBack();
+		}
+		const { run, keep: { keep, characters, audio } } = createQueueProcessor(queue, {
+			skip,
+			skipPreserve
+		});
+		if (context.meta.goingBack)
+ /**
+		* Context is cleared at exit, so it is dirty only when goingBack
+		*/
+		match("clear", [
+			keep,
+			characters,
+			audio
+		], {
+			ctx: context,
+			data: latest[1]
+		});
+		context.loading(false);
+		const lastQueueItem = queue.at(-1);
+		const lastQueueItemRequiresUserAction = lastQueueItem && isBlockingAction(lastQueueItem);
+		await run((item) => {
+			if (!latest) return;
+			/**
+			* Skip because last item will be ran again by `render(context)` call
+			*/
+			if (lastQueueItem === item && lastQueueItemRequiresUserAction) return;
+			const [action, ...props] = item;
+			if (action === "custom") {
+				/**
+				* We check if there's an existing cleanup function for this action.
+				* If found, it means the previous run hasn't been cleaned up yet.
+				* In that case, we avoid re-running.
+				*/
+				if (instances.some((instance) => instance.fn === props[0] && !instance.disposed)) return;
+			}
+			return match(action, props, {
+				ctx: context,
+				data: latest[1]
+			});
+		});
+		if (!context.meta.goingBack)
+ /**
+		* When not goingBack setting restoring to false is required to go forward
+		* Because when restoring action do not call the resolve function which goes to next action but are controlled
+		*/
+		context.meta.restoring = false;
+		await render(context);
+		context.meta.restoring = context.meta.goingBack = false;
+	};
+	const { refer, referGuarded } = createReferFunction({
+		story,
+		onUnknownSceneHit
+	});
+	/**
+	* @param force Force exit
+	*/
+	const exit = (force = false, saving = true) => {
+		/**
+		* Exit only possible in main context
+		*/
+		const ctx = renderer.getContext(MAIN_CONTEXT_KEY);
+		const stack = useStack(ctx);
+		const current = stack.value;
+		const isSaved = () => {
+			const { saves } = storageData.get();
+			const [currentPath, currentData] = stack.value;
+			return saves.some(([path, data, [date, type]]) => type === "manual" && times.has(date) && dequal(path, currentPath) && dequal(data, currentData));
+		};
+		if (interacted > 1 && !force && askBeforeExit && !isSaved()) {
+			renderer.ui.showExitPrompt();
+			return;
+		}
+		/**
+		* Imagine list of actions like
+		*
+		* [
+		*  ['input', ...args]
+		*  ['dialog', ...args]
+		* ]
+		*
+		* When you have done with input, you will go to the dialog
+		* And at that moment you exit the game
+		*
+		* What happens? Input was "enmemoried", but dialog not. So when you will open saves, you'll see input action.
+		* We cannot "enmemory" dialog when it's just started, because goingBack is going to last enmemoried item, which will be that dialog, so impossible to go back.
+		*
+		* What we do is enmemory on exit.
+		*/
+		if (interacted > 0 && saving) save("auto");
+		stack.clear();
+		clearCustomActionsAtContext(ctx);
+		ctx.clear(EMPTY_SET, EMPTY_SET, {
+			music: EMPTY_SET,
+			sounds: EMPTY_SET
+		}, noop);
+		renderer.ui.showScreen("mainmenu");
+		ctx.audio.destroy();
+		const [time, type] = current[2];
+		/**
+		* This is auto save and belongs to the current session
+		* Player did not interacted or did it once, so this is probably not-needed save
+		*/
+		if (type === "auto" && interacted <= 1 && times.has(time)) storageData.update((prev) => {
+			prev.saves = prev.saves.filter((save) => save !== current);
+			return prev;
+		});
+		/**
+		* Reset interactive value
+		*/
+		interactivity(false);
+		/**
+		* Reset session times
+		*/
+		times.clear();
+	};
+	const back = async () => {
+		/**
+		* Back also happens in main context only
+		*/
+		const stack = useStack(MAIN_CONTEXT_KEY);
+		const valueBeforeBack = stack.value;
+		stack.back();
+		/**
+		* There was only one item in the stack so there is no `stack.previous`, also `ctx.meta.goingBack` did not changed
+		*/
+		if (dequal(valueBeforeBack, stack.value) && !stack.previous) return;
+		await restore(stack.value);
+	};
+	const t = (key, lang) => {
+		return translation[lang].internal[key];
+	};
+	/**
+	* Execute save in context named `name`
+	* @param save Save
+	* @param name Context name
+	*/
+	const preview = async (save, name) => {
+		if (isEmpty(story)) return Promise.resolve({ assets: [] });
+		const [path, data] = save;
+		const ctx = renderer.getContext(name);
+		const { found } = await refer(path);
+		if (found) ctx.loading(true);
+		const { queue } = await getActionsFromPath({
+			story,
+			path,
+			filter: true,
+			referGuarded
+		});
+		ctx.loading(false);
+		ctx.meta.restoring = true;
+		ctx.meta.preview = true;
+		const processor = createQueueProcessor(queue, { skip: EMPTY_SET });
+		useStack(ctx).push(clone(save));
+		const assets = [];
+		const huntPromises = [];
+		await processor.run(([action, ...props]) => {
+			if (isAudioAction(action)) return;
+			if (action === "vibrate") return;
+			if (action === "end") return;
+			const huntPromise = huntAssets({
+				action,
+				props,
+				characters,
+				lang: getLanguageFromStore(storageData),
+				volume: getVolumeFromStore(storageData),
+				handle: assets.push.bind(assets),
+				request
+			});
+			huntPromises.push(huntPromise);
+			return match(action, props, {
+				ctx,
+				data
+			});
+		});
+		await Promise.all(huntPromises);
+		return { assets };
+	};
+	const removeContext = (name) => {
+		STACK_MAP.delete(name);
+	};
+	const getStateAtCtx = (context) => {
+		return useStack(context).value[1];
+	};
+	const getStateFunction = (context) => {
+		const stack = useStack(context);
+		const state = ((value) => {
+			const _state = getStateAtCtx(context);
+			if (!value) return _state;
+			const prev = _state;
+			const val = isFunction(value) ? value(prev) : merge(prev, value);
+			stack.value[1] = val;
+		});
+		return state;
+	};
+	const getLanguageDisplayName = (lang) => {
+		const language = translation[lang];
+		if (DEV && !language) throw new Error(`Attempt to use unsupported language "${language}". Supported languages: ${languages.join(", ")}.`);
+		return capitalize(language.nameOverride || getIntlLanguageDisplayName(lang));
+	};
+	const clearCustomActionsAtContext = (ctx) => {
+		const instances = getCustomActionInstances(ctx);
+		const nodeCleanup = /* @__PURE__ */ new Set();
+		for (const instance of instances) {
+			cleanInstance(instance);
+			nodeCleanup.add(instance.node);
+		}
+		instances.length = 0;
+		nodeCleanup.forEach((fn) => fn());
+	};
+	const getResourseTypeWrapper = (url) => {
+		return getResourseType({
+			url,
+			request
+		});
+	};
+	const getCharacterColor = (c) => {
+		return c in characters ? characters[c].color : "#000000";
+	};
+	const getCharacterAssets = (character, emotion) => {
+		return toArray(characters[character].emotions[emotion]).map(unwrapImageAsset);
+	};
+	const getCharacterName = (character) => {
+		const c = character;
+		const cs = characters;
+		const lang = getLanguageFromStore(storageData);
+		if (c && c in cs) {
+			const block = cs[c].name;
+			if (typeof block === "string") return block;
+			if (lang in block) return block[lang];
+		}
+		return String(c);
+	};
+	const setLanguage = (lang) => {
+		storageData.update((prev) => {
+			if (languages.includes(lang)) prev.meta[0] = lang;
+			if (lang === prev.meta[0]) {
+				setDocumentLanguage(lang);
+				onLanguageChange?.(lang);
+			}
+			return prev;
+		});
+	};
+	const renderer = createRenderer({
+		mainContextKey: MAIN_CONTEXT_KEY,
+		characters: getCharactersData(characters),
+		characterAssetSizes,
+		set,
+		restore,
+		save,
+		newGame,
+		exit,
+		back,
+		t,
+		preview,
+		removeContext,
+		getStateFunction,
+		clearCustomActionsAtContext,
+		languages,
+		storageData,
+		coreData,
+		getLanguageDisplayName,
+		getCharacterColor,
+		getCharacterAssets,
+		getDialogOverview: getDialogOverview.bind({
+			referGuarded,
+			story,
+			getCharacterName,
+			getLanguage: () => getLanguageFromStore(storageData),
+			getStack: () => useStack(MAIN_CONTEXT_KEY),
+			templateReplace: (...args) => templateReplace(...args)
+		}),
+		getResourseType: getResourseTypeWrapper,
+		setLanguage
+	});
+	const useStack = createUseStackFunction(renderer);
+	/**
+	* Initiate
+	*/
+	useStack(MAIN_CONTEXT_KEY).push(initial);
+	const UIInstance = renderer.ui.start();
+	const enmemory = (ctx) => {
+		if (ctx.meta.restoring) return;
+		const stack = useStack(ctx);
+		const current = clone(stack.value);
+		current[2][1] = "auto";
+		stack.push(current);
+		save("auto");
+	};
+	const ticker = new TickerFactory(paused);
+	const next = (ctx) => {
+		const path = useStack(ctx).value[0];
+		nextPath(path);
+	};
+	const matchActionHandlers = {
+		getContext: renderer.getContext,
+		async push(ctx) {
+			if (ctx.meta.restoring) return;
+			const stack = useStack(ctx);
+			const instances = getCustomActionInstances(ctx).filter((i) => !i.disposed);
+			next(ctx);
+			if (stack.value && instances.length !== 0) {
+				const action = await refer(stack.value[0]).then((r) => r.value);
+				const params = {
+					action,
+					isBlockingAction: isBlockingAction(action),
+					isUserRequiredAction: isUserRequiredAction(action)
+				};
+				for (const instance of instances) instance.onForward(params);
+			}
+			await render(ctx);
+		},
+		async forward(ctx) {
+			if (!ctx.meta.preview) enmemory(ctx);
+			await matchActionHandlers.push(ctx);
+			if (!ctx.meta.preview) interactivity(true);
+		},
+		async onBeforeActionCall({ action, props, ctx }) {
+			if (preloadAssets !== "automatic") return;
+			if (ctx.meta.preview || ctx.meta.restoring) return;
+			if (!isBlockingAction([action, ...props])) return;
+			try {
+				const queue = (await collectActionsBeforeBlockingAction({
+					path: nextPath(clone(useStack(ctx).value[0])),
+					refer: referGuarded,
+					clone
+				})).map(([action, ...props]) => {
+					return huntAssets({
+						action,
+						props,
+						characters,
+						lang: getLanguageFromStore(storageData),
+						volume: getVolumeFromStore(storageData),
+						handle: enqueueAssetForPreloading,
+						request
+					});
+				});
+				await Promise.all(queue);
+				handleAssetsPreloading({
+					...renderer.misc,
+					request,
+					limiter: limitAssetsDownload
+				});
+			} catch (cause) {
+				console.error(cause);
+			}
+		}
+	};
+	const { match, nativeActions } = matchAction(matchActionHandlers, {
+		wait({ ctx, data, push }, [time]) {
+			if (ctx.meta.restoring) return;
+			setTimeout(push, isFunction(time) ? time(data) : time);
+		},
+		showBackground({ ctx, push }, [background]) {
+			if (isString(background) || isAsset(background)) ctx.background({ all: unwrapImageAsset(background) });
+			else ctx.background(Object.fromEntries(Object.entries(background).map(([media, asset]) => [media, unwrapImageAsset(asset)])));
+			push();
+		},
+		playMusic({ ctx, push }, [source]) {
+			ctx.audio.music(unwrapAudioAsset(source), paused, "music").play(true);
+			push();
+		},
+		pauseMusic({ ctx, push }, [source]) {
+			ctx.audio.music(unwrapAudioAsset(source), paused, "music").pause();
+			push();
+		},
+		stopMusic({ ctx, push }, [source]) {
+			ctx.audio.music(unwrapAudioAsset(source), paused, "music").stop();
+			push();
+		},
+		playSound({ ctx, push }, [source, loop]) {
+			ctx.audio.music(unwrapAudioAsset(source), paused, "sound").play(loop || false);
+			push();
+		},
+		pauseSound({ ctx, push }, [source]) {
+			ctx.audio.music(unwrapAudioAsset(source), paused, "sound").pause();
+			push();
+		},
+		stopSound({ ctx, push }, [source]) {
+			ctx.audio.music(unwrapAudioAsset(source), paused, "sound").stop();
+			push();
+		},
+		voice({ ctx, push }, [source]) {
+			const lang = getLanguageFromStore(storageData);
+			const audioSource = isString(source) ? source : isAsset(source) ? source : source[lang];
+			/**
+			* We allow ignoring voice because it is okay to not have voiceover for certain languages
+			*/
+			if (!audioSource) {
+				push();
+				return;
+			}
+			ctx.audio.voice(unwrapAudioAsset(audioSource), paused);
+			push();
+		},
+		stopVoice({ ctx, push }) {
+			ctx.audio.voiceStop();
+			push();
+		},
+		showCharacter({ ctx, push }, [character, emotion, className, style]) {
+			emotion ??= defaultEmotions[character];
+			if (DEV && !emotion) throw new Error(`Attemp to show character "${character}" without emotion provided.`);
+			if (!emotion) return;
+			if (DEV && !characters[character].emotions[emotion]) throw new Error(`Attempt to show character "${character}" with unknown emotion "${emotion}"`);
+			const handle = ctx.character(character);
+			handle.append(className, style, ctx.meta.restoring);
+			handle.emotion(emotion, true);
+			push();
+		},
+		hideCharacter({ ctx, push }, [character, className, style, duration]) {
+			ctx.character(character).remove(className, style, duration, ctx.meta.restoring).then(push);
+		},
+		dialog({ ctx, data, forward }, [character, content, emotion]) {
+			const name = getCharacterName(character);
+			const stack = useStack(ctx);
+			/**
+			* For each "dialog" we save copy of current game state
+			* It's used for dialog overview
+			*/
+			if (!ctx.meta.restoring && !ctx.meta.goingBack) stack.value[3].push(clone(data));
+			ctx.clearBlockingActions("dialog");
+			ctx.dialog(templateReplace(content, data), templateReplace(name, data), character, emotion, forward);
+		},
+		function({ ctx, push }, [fn]) {
+			const { restoring, goingBack, preview } = ctx.meta;
+			const result = fn({
+				lang: getLanguageFromStore(storageData),
+				goingBack,
+				restoring,
+				preview,
+				state: getStateFunction(ctx)
+			});
+			if (!ctx.meta.restoring) result ? result.then(push) : push();
+			return result;
+		},
+		choice({ ctx, data }, [question, ...choices]) {
+			const isWithoutQuestion = Array.isArray(question);
+			if (isWithoutQuestion) {
+				/**
+				* Can be string or a choice
+				*/
+				choices.unshift(question);
+				/**
+				* Omitted then
+				*/
+				question = "";
+			}
+			const transformedChoices = choices.map(([content, _children, active, visible, onSelect, image]) => {
+				const active$ = store(false);
+				const visible$ = store(false);
+				const lang = getLanguageFromStore(storageData);
+				const getCheckValue = (fn) => {
+					if (!fn) return true;
+					return fn({
+						lang,
+						state: getStateAtCtx(ctx)
+					});
+				};
+				const update = () => {
+					active$.set(getCheckValue(active));
+					visible$.set(getCheckValue(visible));
+				};
+				update();
+				const onSelectGuarded = onSelect || noop;
+				const onSelectWrapped = () => {
+					onSelectGuarded({ recompute: update });
+				};
+				const imageValue = image ? unwrapImageAsset(image) : "";
+				return [
+					templateReplace(content, data),
+					active$,
+					visible$,
+					onSelectWrapped,
+					imageValue
+				];
+			});
+			if (DEV && transformedChoices.length === 0) throw new Error(`Running choice without variants to choose from, look at how to use Choice action properly [https://novely.pages.dev/guide/actions/choice#usage]`);
+			ctx.clearBlockingActions("choice");
+			ctx.choices(templateReplace(question, data), transformedChoices, (selected) => {
+				if (!ctx.meta.preview) enmemory(ctx);
+				const stack = useStack(ctx);
+				/**
+				* If there is a question, then `index` should be shifted by `1`
+				*/
+				const offset = isWithoutQuestion ? 0 : 1;
+				if (DEV && !transformedChoices[selected]) throw new Error("Choice children is empty, either add content there or make item not selectable");
+				stack.value[0].push(["choice", selected + offset], [null, 0]);
+				render(ctx);
+				interactivity(true);
+			});
+		},
+		jump({ ctx, data }, [scene]) {
+			const stack = useStack(ctx);
+			/**
+			* `-1` index is used here because `clear` will run `next` that will increase index to `0`
+			*/
+			stack.value[0] = [["jump", scene], [null, -1]];
+			stack.value[3] = [];
+			match("clear", [], {
+				ctx,
+				data
+			});
+		},
+		clear({ ctx, push }, [keep, characters, audio]) {
+			/**
+			* Remove vibration
+			*/
+			ctx.vibrate(0);
+			/**
+			* Call the actual `clear`
+			*/
+			ctx.clear(keep || EMPTY_SET, characters || EMPTY_SET, audio || {
+				music: EMPTY_SET,
+				sounds: EMPTY_SET
+			}, push);
+		},
+		condition({ ctx, data }, [condition, variants]) {
+			if (DEV && Object.values(variants).length === 0) throw new Error(`Attempt to use Condition action with empty variants object`);
+			if (!ctx.meta.restoring) {
+				const val = String(condition(data));
+				if (DEV && !variants[val]) throw new Error(`Attempt to go to unknown variant "${val}"`);
+				if (DEV && variants[val].length === 0) throw new Error(`Attempt to go to empty variant "${val}"`);
+				useStack(ctx).value[0].push(["condition", val], [null, 0]);
+				render(ctx);
+			}
+		},
+		end({ ctx }) {
+			if (ctx.meta.preview) return;
+			exit(true, false);
+		},
+		input({ ctx, data, forward }, [question, onInput, setup]) {
+			ctx.clearBlockingActions("input");
+			ctx.input(templateReplace(question, data), onInput, setup || noop, forward);
+		},
+		custom({ ctx, push }, [fn]) {
+			if (fn.requireUserAction) ctx.clearBlockingActions(void 0);
+			const state = getStateFunction(ctx);
+			const lang = getLanguageFromStore(storageData);
+			const result = handleCustomAction(ctx, fn, {
+				...ctx.custom(fn),
+				state,
+				lang,
+				getStack: useStack,
+				paused,
+				ticker: ticker.fork(),
+				templateReplace,
+				request
+			});
+			const next = () => {
+				if (fn.requireUserAction && !ctx.meta.preview) {
+					enmemory(ctx);
+					interactivity(true);
+				}
+				push();
+			};
+			if (!ctx.meta.restoring || ctx.meta.goingBack) if (isPromise(result)) result.then(next);
+			else next();
+			return result;
+		},
+		vibrate({ ctx, push }, pattern) {
+			ctx.vibrate(pattern);
+			push();
+		},
+		next({ push }) {
+			push();
+		},
+		animateCharacter({ ctx, push }, [character, className]) {
+			const classes = className.split(" ");
+			if (DEV && classes.length === 0) throw new Error("Attempt to use AnimateCharacter without classes. Classes should be provided [https://novely.pages.dev/guide/actions/animateCharacter.html]");
+			if (ctx.meta.preview) return;
+			ctx.character(character).animate(classes);
+			push();
+		},
+		text({ ctx, data, forward }, text) {
+			const string = text.map((content) => templateReplace(content, data)).join(" ");
+			if (DEV && string.length === 0) throw new Error(`Action Text was called with empty string or array`);
+			ctx.clearBlockingActions("text");
+			ctx.text(string, forward);
+		},
+		async exit({ ctx, data }) {
+			if (ctx.meta.restoring) return;
+			const { exitImpossible } = await exitPath({
+				path: useStack(ctx).value[0],
+				refer: referGuarded,
+				onExitImpossible: () => {
+					match("end", [], {
+						ctx,
+						data
+					});
+				}
+			});
+			if (exitImpossible) {
+				ctx.clearBlockingActions(void 0);
+				return;
+			}
+			render(ctx);
+		},
+		preload({ ctx, push }, [source]) {
+			if (DEV && preloadAssets !== "lazy") {
+				console.error(`You do not need a preload action because "preloadAssets" strategy was set to "${preloadAssets}"`);
+				push();
+				return;
+			}
+			const src = unwrapAsset(source);
+			if (!ctx.meta.goingBack && !ctx.meta.restoring && !PRELOADED_ASSETS.has(src)) {
+				const process = async () => {
+					const type = isAsset(source) ? source.type : await getResourseTypeWrapper(src);
+					if (type === "image") renderer.misc.preloadAudioBlocking(src);
+					else if (type === "audio") renderer.misc.preloadImage(src);
+					else {
+						if (DEV) console.error(`Preload error: Unknown type of the following resource: `, source);
+						return;
+					}
+					PRELOADED_ASSETS.add(src);
+				};
+				process();
+			}
+			push();
+		},
+		block({ ctx }, [scene]) {
+			if (DEV && !story[scene]) throw new Error(`Attempt to call Block action with unknown scene "${scene}"`);
+			if (DEV && story[scene].length === 0) throw new Error(`Attempt to call Block action with empty scene "${scene}"`);
+			if (!ctx.meta.restoring) {
+				useStack(ctx).value[0].push(["block", scene], [null, 0]);
+				render(ctx);
+			}
+		}
+	});
+	const action = buildActionObject({
+		rendererActions: renderer.actions,
+		nativeActions,
+		characters
+	});
+	const render = async (ctx) => {
+		const [path, state] = useStack(ctx).value;
+		const { found, value } = await refer(path);
+		if (found) ctx.loading(true);
+		const referred = await value;
+		if (found) ctx.loading(false);
+		if (isAction(referred)) {
+			const [action, ...props] = referred;
+			match(action, props, {
+				ctx,
+				data: state
+			});
+		} else if (Object.values(story).some((branch) => branch === referred))
+ /**
+		* Developer might not write the end action on their own, so we will catch situation when there are no other options than end the game.
+		*
+		* There are three options right now.
+		* - We've got to the action — gonna render it
+		* - We've got `undefined`. This means we are tried to go forward, but story array ended already, so we are gonna run exit
+		* - We've got branch of story object. This means we exitied from where it's possible to exit and now we can only end the game
+		*/
+		match("end", [], {
+			ctx,
+			data: state
+		});
+		else match("exit", [], {
+			ctx,
+			data: state
+		});
+	};
+	const interactivity = (value = false) => {
+		interacted = value ? interacted + 1 : 0;
+	};
+	/**
+	* Replaces content inside of {{braces}}.
+	*/
+	const templateReplace = (content, values) => {
+		const { data, meta: [lang] } = storageData.get();
+		const obj = values || data;
+		const str = flattenAllowedContent(!isFunction(content) && !isString(content) ? content[lang] : content, obj);
+		const t = translation[lang];
+		const pluralRules = (t.plural || t.actions) && new Intl.PluralRules(t.tag || lang);
+		return replace(str, obj, t.plural, t.actions, pluralRules);
+	};
+	const data = ((value) => {
+		const _data = storageData.get().data;
+		if (!value) return _data;
+		const val = isFunction(value) ? value(_data) : merge(_data, value);
+		storageData.update((prev) => {
+			prev.data = val;
+			return prev;
+		});
+	});
+	const getCurrentStorageData = () => {
+		return coreData.get().dataLoaded ? clone(storageData.get()) : null;
+	};
+	const setStorageData = (data) => {
+		if (destroyed) {
+			if (DEV) throw new Error(`function \`setStorageData\` was called after novely instance was destroyed. Data is not updater nor synced after destroy.`);
+			return;
+		}
+		storageData.set(data);
+	};
+	return {
+		script,
+		action,
+		state: getStateFunction(MAIN_CONTEXT_KEY),
+		data,
+		types: null,
+		templateReplace(content) {
+			return templateReplace(content);
+		},
+		templateReplaceState(content, state) {
+			return templateReplace(content, state);
+		},
+		destroy() {
+			if (destroyed) return;
+			dataLoaded.cancel();
+			UIInstance.unmount();
+			ticker.destroy();
+			removeEventListener("beforeunload", throttledShortOnStorageDataChange);
+			destroyed = true;
+		},
+		getCurrentStorageData,
+		setStorageData,
+		setPaused: (paused) => {
+			coreData.update((prev) => {
+				prev.paused = paused;
+				return prev;
+			});
+		},
+		setFocused: (focused) => {
+			coreData.update((prev) => {
+				prev.focused = focused;
+				return prev;
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/extend-actions.ts
+/**
+* Extens core action with custom actions
+* @param base Actions object you will extend, `engine.action`
+* @param extension Actions object you will extend with
+* @example
+* ```ts
+* const action = extendAction(engine.action, {
+*   particles: (options: Parameters<typeof particles>[0]) => {
+*     return ['custom', particles(options)]
+*   }
+* })
+* ```
+*/
+const extendAction = (base, extension) => {
+	return {
+		...extension,
+		...base
+	};
+};
+
+//#endregion
+//#region src/translations.ts
+const RU = {
+	NewGame: "Новая игра",
+	HomeScreen: "Главный экран",
+	ToTheGame: "К игре",
+	Language: "Язык",
+	NoSaves: "Сохранений нет",
+	LoadSave: "Загрузить",
+	Saves: "Сохранения",
+	Settings: "Настройки",
+	Sumbit: "Подтвердить",
+	GoBack: "Назад",
+	DoSave: "Сохранение",
+	Auto: "Авто",
+	Stop: "Стоп",
+	Exit: "Выход",
+	Automatic: "Автоматическое",
+	Manual: "Ручное",
+	Remove: "Удалить",
+	LoadASaveFrom: "Загрузить сохранение от",
+	DeleteASaveFrom: "Удалить сохранение от",
+	TextSpeed: "Скорость текста",
+	TextSpeedSlow: "Медленная",
+	TextSpeedMedium: "Средняя",
+	TextSpeedFast: "Быстрая",
+	TextSpeedAuto: "Автоматическая",
+	CompleteText: "Завершить текст",
+	GoForward: "Перейти вперёд",
+	ExitDialogWarning: "Вы уверены, что хотите выйти? Прогресс будет сохранён.",
+	ExitDialogExit: "Выйти",
+	ExitDialogBack: "Вернуться в игру",
+	OpenMenu: "Открыть меню",
+	CloseMenu: "Закрыть меню",
+	MusicVolume: "Громкость музыки",
+	SoundVolume: "Громкость звуков",
+	VoiceVolume: "Громкость речи",
+	Close: "Закрыть",
+	DialogOverview: "Обзор диалога"
+};
+const EN = {
+	NewGame: "New Game",
+	HomeScreen: "Home Screen",
+	ToTheGame: "To the Game",
+	Language: "Language",
+	NoSaves: "No saves",
+	LoadSave: "Load",
+	Saves: "Saves",
+	Settings: "Settings",
+	Sumbit: "Submit",
+	GoBack: "Go back",
+	DoSave: "Save",
+	Auto: "Auto",
+	Stop: "Stop",
+	Exit: "Exit",
+	Automatic: "Automatic",
+	Manual: "Manual",
+	Remove: "Remove",
+	LoadASaveFrom: "Load a save from",
+	DeleteASaveFrom: "Delete a save from",
+	TextSpeed: "Text Speed",
+	TextSpeedSlow: "Slow",
+	TextSpeedMedium: "Medium",
+	TextSpeedFast: "Fast",
+	TextSpeedAuto: "Auto",
+	CompleteText: "Complete text",
+	GoForward: "Go forward",
+	ExitDialogWarning: "Are you sure you want to exit? Progress will be saved.",
+	ExitDialogExit: "Exit",
+	ExitDialogBack: "Return to game",
+	OpenMenu: "Open menu",
+	CloseMenu: "Close menu",
+	MusicVolume: "Music volume",
+	SoundVolume: "Sound volume",
+	VoiceVolume: "Voice volume",
+	Close: "Close",
+	DialogOverview: "Dialog Overview"
+};
+
+//#endregion
+//#region src/browser-events.ts
+const BLUR_HANDLERS = /* @__PURE__ */ new Set();
+const FOCUS_HANDLERS = /* @__PURE__ */ new Set();
+const registerEventListeners = (listeners) => {
+	BLUR_HANDLERS.add(listeners.blur);
+	FOCUS_HANDLERS.add(listeners.focus);
+	return () => {
+		BLUR_HANDLERS.delete(listeners.blur);
+		FOCUS_HANDLERS.delete(listeners.focus);
+	};
+};
+addEventListener("focus", function(event) {
+	for (const handler of FOCUS_HANDLERS) try {
+		handler.call(this.document, event);
+	} catch {}
+});
+addEventListener("blur", function(event) {
+	for (const handler of BLUR_HANDLERS) try {
+		handler.call(this.document, event);
+	} catch {}
+});
+const pauseOnBlur = (engine) => {
+	return { unsubscribe: registerEventListeners({
+		focus: () => {
+			engine.setFocused(true);
+		},
+		blur: () => {
+			engine.setFocused(false);
+		}
+	}) };
+};
+
+//#endregion
+export { EN, RU, asset, extendAction, novely, pauseOnBlur, storageAdapterLocal };
+//# sourceMappingURL=index.mjs.map