@novely/core 0.38.2 → 0.39.0

package/dist/index.global.js

@@ -25,6 +25,7 @@ var Novely = (() => {
     JP: () => JP,
     KK: () => KK,
     RU: () => RU,
+    asset: () => asset,
     extendAction: () => extendAction,
     localStorageStorage: () => localStorageStorage,
     novely: () => novely
@@ -81,7 +82,7 @@ var Novely = (() => {
   var STACK_MAP = /* @__PURE__ */ new Map();
   var CUSTOM_ACTION_MAP = /* @__PURE__ */ new Map();
   var PRELOADED_ASSETS = /* @__PURE__ */ new Set();
-  var RESOURCE_TYPE_CACHE = /* @__PURE__ */ new Map();
+  var ASSETS_TO_PRELOAD = /* @__PURE__ */ new Set();
 
   // ../../node_modules/.pnpm/esm-env@1.0.0/node_modules/esm-env/prod-ssr.js
   var DEV = false;
@@ -113,6 +114,404 @@ var Novely = (() => {
     return val;
   }
 
+  // ../../node_modules/.pnpm/micro-memoize@4.1.2/node_modules/micro-memoize/dist/micro-memoize.esm.js
+  var DEFAULT_OPTIONS_KEYS = {
+    isEqual: true,
+    isMatchingKey: true,
+    isPromise: true,
+    maxSize: true,
+    onCacheAdd: true,
+    onCacheChange: true,
+    onCacheHit: true,
+    transformKey: true
+  };
+  var slice = Array.prototype.slice;
+  function cloneArray(arrayLike) {
+    var length = arrayLike.length;
+    if (!length) {
+      return [];
+    }
+    if (length === 1) {
+      return [arrayLike[0]];
+    }
+    if (length === 2) {
+      return [arrayLike[0], arrayLike[1]];
+    }
+    if (length === 3) {
+      return [arrayLike[0], arrayLike[1], arrayLike[2]];
+    }
+    return slice.call(arrayLike, 0);
+  }
+  function getCustomOptions(options) {
+    var customOptions = {};
+    for (var key in options) {
+      if (!DEFAULT_OPTIONS_KEYS[key]) {
+        customOptions[key] = options[key];
+      }
+    }
+    return customOptions;
+  }
+  function isMemoized(fn) {
+    return typeof fn === "function" && fn.isMemoized;
+  }
+  function isSameValueZero(object1, object2) {
+    return object1 === object2 || object1 !== object1 && object2 !== object2;
+  }
+  function mergeOptions(existingOptions, newOptions) {
+    var target = {};
+    for (var key in existingOptions) {
+      target[key] = existingOptions[key];
+    }
+    for (var key in newOptions) {
+      target[key] = newOptions[key];
+    }
+    return target;
+  }
+  var Cache = (
+    /** @class */
+    function() {
+      function Cache2(options) {
+        this.keys = [];
+        this.values = [];
+        this.options = options;
+        var isMatchingKeyFunction = typeof options.isMatchingKey === "function";
+        if (isMatchingKeyFunction) {
+          this.getKeyIndex = this._getKeyIndexFromMatchingKey;
+        } else if (options.maxSize > 1) {
+          this.getKeyIndex = this._getKeyIndexForMany;
+        } else {
+          this.getKeyIndex = this._getKeyIndexForSingle;
+        }
+        this.canTransformKey = typeof options.transformKey === "function";
+        this.shouldCloneArguments = this.canTransformKey || isMatchingKeyFunction;
+        this.shouldUpdateOnAdd = typeof options.onCacheAdd === "function";
+        this.shouldUpdateOnChange = typeof options.onCacheChange === "function";
+        this.shouldUpdateOnHit = typeof options.onCacheHit === "function";
+      }
+      Object.defineProperty(Cache2.prototype, "size", {
+        /**
+         * The number of cached [key,value] results.
+         */
+        get: function() {
+          return this.keys.length;
+        },
+        enumerable: false,
+        configurable: true
+      });
+      Object.defineProperty(Cache2.prototype, "snapshot", {
+        /**
+         * A copy of the cache at a moment in time. This is useful
+         * to compare changes over time, since the cache mutates
+         * internally for performance reasons.
+         */
+        get: function() {
+          return {
+            keys: cloneArray(this.keys),
+            size: this.size,
+            values: cloneArray(this.values)
+          };
+        },
+        enumerable: false,
+        configurable: true
+      });
+      Cache2.prototype._getKeyIndexFromMatchingKey = function(keyToMatch) {
+        var _a = this.options, isMatchingKey = _a.isMatchingKey, maxSize = _a.maxSize;
+        var keys2 = this.keys;
+        var keysLength = keys2.length;
+        if (!keysLength) {
+          return -1;
+        }
+        if (isMatchingKey(keys2[0], keyToMatch)) {
+          return 0;
+        }
+        if (maxSize > 1) {
+          for (var index = 1; index < keysLength; index++) {
+            if (isMatchingKey(keys2[index], keyToMatch)) {
+              return index;
+            }
+          }
+        }
+        return -1;
+      };
+      Cache2.prototype._getKeyIndexForMany = function(keyToMatch) {
+        var isEqual = this.options.isEqual;
+        var keys2 = this.keys;
+        var keysLength = keys2.length;
+        if (!keysLength) {
+          return -1;
+        }
+        if (keysLength === 1) {
+          return this._getKeyIndexForSingle(keyToMatch);
+        }
+        var keyLength = keyToMatch.length;
+        var existingKey;
+        var argIndex;
+        if (keyLength > 1) {
+          for (var index = 0; index < keysLength; index++) {
+            existingKey = keys2[index];
+            if (existingKey.length === keyLength) {
+              argIndex = 0;
+              for (; argIndex < keyLength; argIndex++) {
+                if (!isEqual(existingKey[argIndex], keyToMatch[argIndex])) {
+                  break;
+                }
+              }
+              if (argIndex === keyLength) {
+                return index;
+              }
+            }
+          }
+        } else {
+          for (var index = 0; index < keysLength; index++) {
+            existingKey = keys2[index];
+            if (existingKey.length === keyLength && isEqual(existingKey[0], keyToMatch[0])) {
+              return index;
+            }
+          }
+        }
+        return -1;
+      };
+      Cache2.prototype._getKeyIndexForSingle = function(keyToMatch) {
+        var keys2 = this.keys;
+        if (!keys2.length) {
+          return -1;
+        }
+        var existingKey = keys2[0];
+        var length = existingKey.length;
+        if (keyToMatch.length !== length) {
+          return -1;
+        }
+        var isEqual = this.options.isEqual;
+        if (length > 1) {
+          for (var index = 0; index < length; index++) {
+            if (!isEqual(existingKey[index], keyToMatch[index])) {
+              return -1;
+            }
+          }
+          return 0;
+        }
+        return isEqual(existingKey[0], keyToMatch[0]) ? 0 : -1;
+      };
+      Cache2.prototype.orderByLru = function(key, value, startingIndex) {
+        var keys2 = this.keys;
+        var values = this.values;
+        var currentLength = keys2.length;
+        var index = startingIndex;
+        while (index--) {
+          keys2[index + 1] = keys2[index];
+          values[index + 1] = values[index];
+        }
+        keys2[0] = key;
+        values[0] = value;
+        var maxSize = this.options.maxSize;
+        if (currentLength === maxSize && startingIndex === currentLength) {
+          keys2.pop();
+          values.pop();
+        } else if (startingIndex >= maxSize) {
+          keys2.length = values.length = maxSize;
+        }
+      };
+      Cache2.prototype.updateAsyncCache = function(memoized) {
+        var _this = this;
+        var _a = this.options, onCacheChange = _a.onCacheChange, onCacheHit = _a.onCacheHit;
+        var firstKey = this.keys[0];
+        var firstValue = this.values[0];
+        this.values[0] = firstValue.then(function(value) {
+          if (_this.shouldUpdateOnHit) {
+            onCacheHit(_this, _this.options, memoized);
+          }
+          if (_this.shouldUpdateOnChange) {
+            onCacheChange(_this, _this.options, memoized);
+          }
+          return value;
+        }, function(error) {
+          var keyIndex = _this.getKeyIndex(firstKey);
+          if (keyIndex !== -1) {
+            _this.keys.splice(keyIndex, 1);
+            _this.values.splice(keyIndex, 1);
+          }
+          throw error;
+        });
+      };
+      return Cache2;
+    }()
+  );
+  function createMemoizedFunction(fn, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    if (isMemoized(fn)) {
+      return createMemoizedFunction(fn.fn, mergeOptions(fn.options, options));
+    }
+    if (typeof fn !== "function") {
+      throw new TypeError("You must pass a function to `memoize`.");
+    }
+    var _a = options.isEqual, isEqual = _a === void 0 ? isSameValueZero : _a, isMatchingKey = options.isMatchingKey, _b = options.isPromise, isPromise2 = _b === void 0 ? false : _b, _c = options.maxSize, maxSize = _c === void 0 ? 1 : _c, onCacheAdd = options.onCacheAdd, onCacheChange = options.onCacheChange, onCacheHit = options.onCacheHit, transformKey = options.transformKey;
+    var normalizedOptions = mergeOptions({
+      isEqual,
+      isMatchingKey,
+      isPromise: isPromise2,
+      maxSize,
+      onCacheAdd,
+      onCacheChange,
+      onCacheHit,
+      transformKey
+    }, getCustomOptions(options));
+    var cache = new Cache(normalizedOptions);
+    var keys2 = cache.keys, values = cache.values, canTransformKey = cache.canTransformKey, shouldCloneArguments = cache.shouldCloneArguments, shouldUpdateOnAdd = cache.shouldUpdateOnAdd, shouldUpdateOnChange = cache.shouldUpdateOnChange, shouldUpdateOnHit = cache.shouldUpdateOnHit;
+    var memoized = function() {
+      var key = shouldCloneArguments ? cloneArray(arguments) : arguments;
+      if (canTransformKey) {
+        key = transformKey(key);
+      }
+      var keyIndex = keys2.length ? cache.getKeyIndex(key) : -1;
+      if (keyIndex !== -1) {
+        if (shouldUpdateOnHit) {
+          onCacheHit(cache, normalizedOptions, memoized);
+        }
+        if (keyIndex) {
+          cache.orderByLru(keys2[keyIndex], values[keyIndex], keyIndex);
+          if (shouldUpdateOnChange) {
+            onCacheChange(cache, normalizedOptions, memoized);
+          }
+        }
+      } else {
+        var newValue = fn.apply(this, arguments);
+        var newKey = shouldCloneArguments ? key : cloneArray(arguments);
+        cache.orderByLru(newKey, newValue, keys2.length);
+        if (isPromise2) {
+          cache.updateAsyncCache(memoized);
+        }
+        if (shouldUpdateOnAdd) {
+          onCacheAdd(cache, normalizedOptions, memoized);
+        }
+        if (shouldUpdateOnChange) {
+          onCacheChange(cache, normalizedOptions, memoized);
+        }
+      }
+      return values[0];
+    };
+    memoized.cache = cache;
+    memoized.fn = fn;
+    memoized.isMemoized = true;
+    memoized.options = normalizedOptions;
+    return memoized;
+  }
+
+  // src/audio-codecs.ts
+  var cut = (str2) => str2.replace(/^no$/, "");
+  var audio = new Audio();
+  var canPlay = (type) => !!cut(audio.canPlayType(type));
+  var canPlayMultiple = (...types) => types.some((type) => canPlay(type));
+  var supportsMap = {
+    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;")
+  };
+
+  // src/image-formats.ts
+  var avif = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=";
+  var jxl = "data:image/jxl;base64,/woIAAAMABKIAgC4AF3lEgAAFSqjjBu8nOv58kOHxbSN6wxttW1hSaLIODZJJ3BIEkkaoCUzGM6qJAE=";
+  var webp = "data:image/webp;base64,UklGRjoAAABXRUJQVlA4IC4AAACyAgCdASoCAAIALmk0mk0iIiIiIgBoSygABc6WWgAA/veff/0PP8bA//LwYAAA";
+  var 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;
+  };
+  var supportsMap2 = {
+    avif: false,
+    jxl: false,
+    webp: false
+  };
+  var formatsMap = {
+    avif,
+    jxl,
+    webp
+  };
+  var loadImageFormatsSupport = async () => {
+    const promises = [];
+    for (const [format, source] of Object.entries(formatsMap)) {
+      const promise = supportsFormat(source).then((supported) => {
+        supportsMap2[format] = supported;
+      });
+      promises.push(promise);
+    }
+    await Promise.all(promises);
+  };
+  loadImageFormatsSupport();
+
+  // src/asset.ts
+  var getType = createMemoizedFunction((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";
+    }
+    throw extensions;
+  });
+  var SUPPORT_MAPS = {
+    "image": supportsMap2,
+    "audio": supportsMap
+  };
+  var asset = createMemoizedFunction((...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 = createMemoizedFunction(() => {
+      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;
+      }
+    };
+  });
+  var isAsset = (suspect) => {
+    return suspect !== null && typeof suspect === "object" && "source" in suspect && "type" in suspect;
+  };
+
   // src/utils.ts
   var matchAction = ({ getContext, onBeforeActionCall, push, forward }, values) => {
     return (action, props, { ctx, data }) => {
@@ -357,7 +756,7 @@ var Novely = (() => {
     const processedQueue = [];
     const keep = /* @__PURE__ */ new Set();
     const characters = /* @__PURE__ */ new Set();
-    const audio = {
+    const audio2 = {
       music: /* @__PURE__ */ new Set(),
       sound: /* @__PURE__ */ new Set()
     };
@@ -382,14 +781,9 @@ var Novely = (() => {
             });
             if (notLatest) continue;
           } else if ("skipOnRestore" in fn && fn.skipOnRestore) {
-            let getNext = () => {
-              const nextActions = next(i);
-              getNext = () => {
-                return nextActions;
-              };
-              return nextActions;
-            };
-            if (fn.skipOnRestore(getNext)) continue;
+            if (fn.skipOnRestore(() => next(i))) {
+              continue;
+            }
           }
         }
         processedQueue.push(item);
@@ -407,9 +801,9 @@ var Novely = (() => {
         if (action === "showCharacter") {
           characters.add(params[0]);
         } else if (action === "playMusic") {
-          audio.music.add(params[0]);
+          audio2.music.add(unwrapAsset(params[0]));
         } else if (action === "playSound") {
-          audio.sound.add(params[0]);
+          audio2.sound.add(unwrapAsset(params[0]));
         }
         processedQueue.push(item);
       } else if (action === "showBackground" || action === "preload") {
@@ -446,7 +840,7 @@ var Novely = (() => {
       keep: {
         keep,
         characters,
-        audio
+        audio: audio2
       }
     };
   };
@@ -493,8 +887,8 @@ var Novely = (() => {
   var mapSet = (set, fn) => {
     return [...set].map(fn);
   };
-  var isImageAsset = (asset) => {
-    return isString(asset) && isCSSImage(asset);
+  var isImageAsset = (asset2) => {
+    return isString(asset2) && isCSSImage(asset2);
   };
   var getUrlFileExtension = (address) => {
     try {
@@ -520,37 +914,35 @@ var Novely = (() => {
       return "";
     }
   };
-  var getResourseType = async (request, url) => {
-    if (RESOURCE_TYPE_CACHE.has(url)) {
-      return RESOURCE_TYPE_CACHE.get(url);
-    }
-    const encache = (value) => {
-      RESOURCE_TYPE_CACHE.set(url, value);
-      return value;
-    };
-    if (!isCSSImage(url)) {
-      return encache("other");
-    }
-    const extension = getUrlFileExtension(url);
-    if (HOWLER_SUPPORTED_FILE_FORMATS.has(extension)) {
-      return encache("audio");
-    }
-    if (SUPPORTED_IMAGE_FILE_FORMATS.has(extension)) {
-      return encache("image");
-    }
-    const contentType = await fetchContentType(request, url);
-    if (contentType.includes("audio")) {
-      return encache("audio");
-    }
-    if (contentType.includes("image")) {
-      return encache("image");
+  var getResourseType = createMemoizedFunction(
+    async (request, url) => {
+      if (!isCSSImage(url)) {
+        return "other";
+      }
+      const extension = getUrlFileExtension(url);
+      if (HOWLER_SUPPORTED_FILE_FORMATS.has(extension)) {
+        return "audio";
+      }
+      if (SUPPORTED_IMAGE_FILE_FORMATS.has(extension)) {
+        return "image";
+      }
+      const contentType = await fetchContentType(request, url);
+      if (contentType.includes("audio")) {
+        return "audio";
+      }
+      if (contentType.includes("image")) {
+        return "image";
+      }
+      return "other";
+    },
+    {
+      isPromise: true
     }
-    return encache("other");
-  };
+  );
   var capitalize = (str2) => {
     return str2[0].toUpperCase() + str2.slice(1);
   };
-  var getIntlLanguageDisplayName = (lang) => {
+  var getIntlLanguageDisplayName = createMemoizedFunction((lang) => {
     try {
       const intl = new Intl.DisplayNames([lang], {
         type: "language"
@@ -559,7 +951,7 @@ var Novely = (() => {
     } catch {
       return lang;
     }
-  };
+  });
   var createReferFunction = (story) => {
     const refer = (path) => {
       let current = story;
@@ -703,6 +1095,29 @@ var Novely = (() => {
     }
     return collection;
   };
+  var unwrapAsset = (asset2) => {
+    return isAsset(asset2) ? asset2.source : asset2;
+  };
+  var handleAudioAsset = (asset2) => {
+    if (DEV && isAsset(asset2) && asset2.type !== "audio") {
+      throw new Error("Attempt to use non-audio asset in audio action", { cause: asset2 });
+    }
+    return unwrapAsset(asset2);
+  };
+  var handleImageAsset = (asset2) => {
+    if (DEV && isAsset(asset2) && asset2.type !== "image") {
+      throw new Error("Attempt to use non-image asset in action that requires image assets", { cause: asset2 });
+    }
+    return unwrapAsset(asset2);
+  };
+  var getCharactersData = (characters) => {
+    const entries = Object.entries(characters);
+    const mapped = entries.map(([key, value]) => [key, { name: value.name, emotions: Object.keys(value.emotions) }]);
+    return Object.fromEntries(mapped);
+  };
+  var toArray = (target) => {
+    return Array.isArray(target) ? target : [target];
+  };
 
   // ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/lite/index.mjs
   var has = Object.prototype.hasOwnProperty;
@@ -1105,6 +1520,66 @@ var Novely = (() => {
     }
   }
 
+  // src/preloading.ts
+  var enqueueAssetForPreloading = (asset2) => {
+    if (!PRELOADED_ASSETS.has(asset2)) {
+      ASSETS_TO_PRELOAD.add(asset2);
+    }
+  };
+  var handleAssetsPreloading = async ({ request, limiter, preloadAudioBlocking, preloadImageBlocking }) => {
+    const list = mapSet(ASSETS_TO_PRELOAD, (asset2) => {
+      return limiter(async () => {
+        const type = await getResourseType(request, asset2);
+        switch (type) {
+          case "audio": {
+            await preloadAudioBlocking(asset2);
+            break;
+          }
+          case "image": {
+            await preloadImageBlocking(asset2);
+            break;
+          }
+        }
+        ASSETS_TO_PRELOAD.delete(asset2);
+        PRELOADED_ASSETS.add(asset2);
+      });
+    });
+    await Promise.allSettled(list);
+    ASSETS_TO_PRELOAD.clear();
+  };
+  var huntAssets = ({ characters, action, props, handle }) => {
+    if (action === "showBackground") {
+      if (isString(props[0])) {
+        handle(handleAudioAsset(props[0]));
+      }
+      if (props[0] && typeof props[0] === "object") {
+        for (const value of Object.values(props[0])) {
+          if (isImageAsset(value)) {
+            handle(value);
+          }
+        }
+      }
+      return;
+    }
+    if (isAudioAction(action) && isString(props[0])) {
+      handle(handleAudioAsset(props[0]));
+      return;
+    }
+    if (action === "showCharacter" && isString(props[0]) && isString(props[1])) {
+      const images = toArray(characters[props[0]].emotions[props[1]]);
+      for (const asset2 of images) {
+        handle(handleImageAsset(asset2));
+      }
+      return;
+    }
+    if (action === "custom" && props[0].assets && props[0].assets.length > 0) {
+      for (const asset2 of props[0].assets) {
+        handle(asset2);
+      }
+      return;
+    }
+  };
+
   // src/novely.ts
   var novely = ({
     characters,
@@ -1134,38 +1609,12 @@ var Novely = (() => {
     const limitAssetsDownload = pLimit(parallelAssetsDownloadLimit);
     const story = {};
     const times = /* @__PURE__ */ new Set();
-    const ASSETS_TO_PRELOAD = /* @__PURE__ */ new Set();
     const dataLoaded = createControlledPromise();
     let initialScreenWasShown = false;
     let destroyed = false;
     const intime = (value) => {
       return times.add(value), value;
     };
-    const handleAssetsPreloading = async () => {
-      const { preloadAudioBlocking, preloadImageBlocking } = renderer.misc;
-      const list = mapSet(ASSETS_TO_PRELOAD, (asset) => {
-        return limitAssetsDownload(async () => {
-          const type = await getResourseType(request, asset);
-          switch (type) {
-            case "audio": {
-              await preloadAudioBlocking(asset);
-              break;
-            }
-            case "image": {
-              await preloadImageBlocking(asset);
-              break;
-            }
-          }
-        });
-      });
-      await Promise.allSettled(list);
-      ASSETS_TO_PRELOAD.clear();
-    };
-    const assetsToPreloadAdd = (asset) => {
-      if (!PRELOADED_ASSETS.has(asset)) {
-        ASSETS_TO_PRELOAD.add(asset);
-      }
-    };
     const scriptBase = async (part) => {
       if (destroyed) return;
       Object.assign(story, flattenStory(part));
@@ -1178,7 +1627,11 @@ var Novely = (() => {
         if (!loadingIsShown) {
           renderer.ui.showLoading();
         }
-        await handleAssetsPreloading();
+        await handleAssetsPreloading({
+          ...renderer.misc,
+          limiter: limitAssetsDownload,
+          request
+        });
       }
       await dataLoaded.promise;
       renderer.ui.hideLoading();
@@ -1194,40 +1647,6 @@ var Novely = (() => {
     const script = (part) => {
       return limitScript(() => scriptBase(part));
     };
-    const assetPreloadingCheck = (action2, props, doAction = assetsToPreloadAdd) => {
-      if (action2 === "showBackground") {
-        if (isImageAsset(props[0])) {
-          doAction(props[0]);
-        }
-        if (props[0] && typeof props[0] === "object") {
-          for (const value of Object.values(props[0])) {
-            if (!isImageAsset(value)) continue;
-            doAction(value);
-          }
-        }
-        return;
-      }
-      if (isAudioAction(action2) && isString(props[0])) {
-        doAction(props[0]);
-        return;
-      }
-      if (action2 === "showCharacter" && isString(props[0]) && isString(props[1])) {
-        const images = characters[props[0]].emotions[props[1]];
-        if (Array.isArray(images)) {
-          for (const asset of images) {
-            doAction(asset);
-          }
-        } else {
-          doAction(images);
-        }
-        return;
-      }
-      if (action2 === "custom" && props[0].assets && props[0].assets.length > 0) {
-        for (const asset of props[0].assets) {
-          doAction(asset);
-        }
-      }
-    };
     const action = new Proxy({}, {
       get(_, action2) {
         if (action2 in renderer.actions) {
@@ -1235,7 +1654,7 @@ var Novely = (() => {
         }
         return (...props) => {
           if (preloadAssets === "blocking") {
-            assetPreloadingCheck(action2, props);
+            huntAssets({ characters, action: action2, props, handle: enqueueAssetForPreloading });
           }
           return [action2, ...props];
         };
@@ -1393,7 +1812,7 @@ var Novely = (() => {
       const [path] = stack.value = latest;
       renderer.ui.showScreen("game");
       const { queue, skip, skipPreserve } = getActionsFromPath(story, path, false);
-      const { run, keep: { keep, characters: characters2, audio } } = createQueueProcessor(queue, {
+      const { run, keep: { keep, characters: characters2, audio: audio2 } } = createQueueProcessor(queue, {
         skip,
         skipPreserve
       });
@@ -1411,7 +1830,7 @@ var Novely = (() => {
         }
       }
       if (context.meta.goingBack) {
-        match("clear", [keep, characters2, audio], {
+        match("clear", [keep, characters2, audio2], {
           ctx: context,
           data: latest[1]
         });
@@ -1498,7 +1917,7 @@ var Novely = (() => {
         if (isAudioAction(action2)) return;
         if (action2 === "vibrate") return;
         if (action2 === "end") return;
-        assetPreloadingCheck(action2, props, assets.push.bind(assets));
+        huntAssets({ characters, action: action2, props, handle: assets.push.bind(assets) });
         return match(action2, props, {
           ctx,
           data: data2
@@ -1541,9 +1960,15 @@ var Novely = (() => {
     const getResourseTypeForRenderer = (url) => {
       return getResourseType(request, url);
     };
+    const getCharacterColor = (c) => {
+      return c in characters ? characters[c].color : "#000000";
+    };
+    const getCharacterAssets = (character, emotion) => {
+      return toArray(characters[character].emotions[emotion]).map(handleImageAsset);
+    };
     const renderer = createRenderer({
       mainContextKey: MAIN_CONTEXT_KEY,
-      characters,
+      characters: getCharactersData(characters),
       characterAssetSizes,
       set,
       restore,
@@ -1560,6 +1985,8 @@ var Novely = (() => {
       storageData,
       coreData,
       getLanguageDisplayName,
+      getCharacterColor,
+      getCharacterAssets,
       getResourseType: getResourseTypeForRenderer
     });
     const useStack = createUseStackFunction(renderer);
@@ -1600,26 +2027,12 @@ var Novely = (() => {
             refer
           });
           for (const [action3, ...props2] of collection) {
-            assetPreloadingCheck(action3, props2);
+            huntAssets({ characters, action: action3, props: props2, handle: enqueueAssetForPreloading });
           }
-          const { preloadAudioBlocking, preloadImageBlocking } = renderer.misc;
-          ASSETS_TO_PRELOAD.forEach(async (asset) => {
-            ASSETS_TO_PRELOAD.delete(asset);
-            const type = await getResourseType(request, asset);
-            switch (type) {
-              case "audio": {
-                preloadAudioBlocking(asset).then(() => {
-                  PRELOADED_ASSETS.add(asset);
-                });
-                break;
-              }
-              case "image": {
-                preloadImageBlocking(asset).then(() => {
-                  PRELOADED_ASSETS.add(asset);
-                });
-                break;
-              }
-            }
+          handleAssetsPreloading({
+            ...renderer.misc,
+            request,
+            limiter: limitAssetsDownload
           });
         } catch (cause) {
           console.error(cause);
@@ -1632,41 +2045,47 @@ var Novely = (() => {
         setTimeout(push, isFunction(time) ? time(getStateAtCtx(ctx)) : time);
       },
       showBackground({ ctx, push }, [background]) {
-        ctx.background(background);
+        if (isString(background) || isAsset(background)) {
+          ctx.background({
+            "all": handleImageAsset(background)
+          });
+        } else {
+          ctx.background(Object.fromEntries(Object.entries(background).map(([media, asset2]) => [media, handleImageAsset(asset2)])));
+        }
         push();
       },
       playMusic({ ctx, push }, [source]) {
-        ctx.audio.music(source, "music").play(true);
+        ctx.audio.music(handleAudioAsset(source), "music").play(true);
         push();
       },
       pauseMusic({ ctx, push }, [source]) {
-        ctx.audio.music(source, "music").pause();
+        ctx.audio.music(handleAudioAsset(source), "music").pause();
         push();
       },
       stopMusic({ ctx, push }, [source]) {
-        ctx.audio.music(source, "music").stop();
+        ctx.audio.music(handleAudioAsset(source), "music").stop();
         push();
       },
       playSound({ ctx, push }, [source, loop]) {
-        ctx.audio.music(source, "sound").play(loop || false);
+        ctx.audio.music(handleAudioAsset(source), "sound").play(loop || false);
         push();
       },
       pauseSound({ ctx, push }, [source]) {
-        ctx.audio.music(source, "sound").pause();
+        ctx.audio.music(handleAudioAsset(source), "sound").pause();
         push();
       },
       stopSound({ ctx, push }, [source]) {
-        ctx.audio.music(source, "sound").stop();
+        ctx.audio.music(handleAudioAsset(source), "sound").stop();
         push();
       },
       voice({ ctx, push }, [source]) {
         const [lang] = storageData.get().meta;
-        const audioSource = isString(source) ? source : source[lang];
+        const audioSource = isString(source) ? source : isAsset(source) ? source : source[lang];
         if (!audioSource) {
           push();
           return;
         }
-        ctx.audio.voice(audioSource);
+        ctx.audio.voice(handleAudioAsset(audioSource));
         push();
       },
       stopVoice({ ctx, push }) {
@@ -1789,12 +2208,12 @@ var Novely = (() => {
           data: data2
         });
       },
-      clear({ ctx, push }, [keep, characters2, audio]) {
+      clear({ ctx, push }, [keep, characters2, audio2]) {
         ctx.vibrate(0);
         ctx.clear(
           keep || EMPTY_SET,
           characters2 || EMPTY_SET,
-          audio || { music: EMPTY_SET, sounds: EMPTY_SET },
+          audio2 || { music: EMPTY_SET, sounds: EMPTY_SET },
           push
         );
       },
@@ -1983,7 +2402,7 @@ var Novely = (() => {
     const setStorageData = (data2) => {
       if (destroyed) {
         if (DEV) {
-          throw new Error(`function \`setStorageData\` was called after novely instance was destroyed.`);
+          throw new Error(`function \`setStorageData\` was called after novely instance was destroyed. Data is not updater nor synced after destroy.`);
         }
         return;
       }