vuepress-plugin-md-power 1.0.0-rc.146 → 1.0.0-rc.148

package/lib/client/components/VPCodeTree.vue

@@ -126,6 +126,13 @@ onMounted(() => {
   border-bottom-left-radius: 0;
 }
 
+@media (min-width: 768px) {
+  .vp-code-tree .code-tree-panel .vp-file-tree,
+  .vp-code-tree .code-panel [class*="language-"] {
+    overscroll-behavior: contain;
+  }
+}
+
 .vp-code-tree .code-panel .code-block-title {
   display: none;
   height: 100%;
@@ -141,6 +148,15 @@ onMounted(() => {
   border-radius: 0;
 }
 
+.vp-code-tree .code-panel div[class*="language-"].has-collapsed-lines.collapsed {
+  height: auto;
+  overflow: auto;
+}
+
+.vp-code-tree .code-panel div[class*="language-"].has-collapsed-lines .collapsed-lines {
+  display: none;
+}
+
 .vp-code-tree .code-panel .code-tree-empty {
   display: flex;
   align-items: center;

package/lib/client/composables/audio.d.ts

@@ -1,40 +1,40 @@
-import * as vue from 'vue';
-import { MaybeRef } from 'vue';
+import { MaybeRef, Ref } from "vue";
 
+//#region src/client/composables/audio.d.ts
 interface BufferedRange {
-    start: number;
-    end: number;
+  start: number;
+  end: number;
 }
 interface AudioPlayerOptions {
-    type?: MaybeRef<string>;
-    autoplay?: boolean;
-    mutex?: boolean;
-    onload?: HTMLAudioElement['onload'];
-    onerror?: HTMLAudioElement['onerror'];
-    onpause?: HTMLAudioElement['onpause'];
-    onplay?: HTMLAudioElement['onplay'];
-    onplaying?: HTMLAudioElement['onplaying'];
-    onseeked?: HTMLAudioElement['onseeked'];
-    onvolume?: (volume: number) => void;
-    onend?: HTMLAudioElement['onended'];
-    onprogress?: (current: number, total: number) => void;
-    oncanplay?: HTMLAudioElement['oncanplay'];
-    oncanplaythrough?: HTMLAudioElement['oncanplaythrough'];
-    ontimeupdate?: (currentTime: number) => void;
-    onwaiting?: HTMLAudioElement['onwaiting'];
+  type?: MaybeRef<string>;
+  autoplay?: boolean;
+  mutex?: boolean;
+  onload?: HTMLAudioElement["onload"];
+  onerror?: HTMLAudioElement["onerror"];
+  onpause?: HTMLAudioElement["onpause"];
+  onplay?: HTMLAudioElement["onplay"];
+  onplaying?: HTMLAudioElement["onplaying"];
+  onseeked?: HTMLAudioElement["onseeked"];
+  onvolume?: (volume: number) => void;
+  onend?: HTMLAudioElement["onended"];
+  onprogress?: (current: number, total: number) => void;
+  oncanplay?: HTMLAudioElement["oncanplay"];
+  oncanplaythrough?: HTMLAudioElement["oncanplaythrough"];
+  ontimeupdate?: (currentTime: number) => void;
+  onwaiting?: HTMLAudioElement["onwaiting"];
 }
-declare function useAudioPlayer(source: MaybeRef<string>, options?: AudioPlayerOptions): {
-    isSupported: vue.Ref<boolean, boolean>;
-    paused: vue.Ref<boolean, boolean>;
-    loaded: vue.Ref<boolean, boolean>;
-    currentTime: vue.Ref<number, number>;
-    duration: vue.Ref<number, number>;
-    player: null;
-    destroy: () => void;
-    play: () => void;
-    pause: () => void | undefined;
-    seek(time: number): void;
-    setVolume(volume: number): void;
-};
-
-export { type AudioPlayerOptions, type BufferedRange, useAudioPlayer };
+interface UseAudioPlayerResult {
+  player: HTMLAudioElement | null;
+  isSupported: Ref<boolean>;
+  loaded: Ref<boolean>;
+  paused: Ref<boolean>;
+  currentTime: Ref<number>;
+  duration: Ref<number>;
+  play: () => void;
+  pause: () => void;
+  seek: (time: number) => void;
+  setVolume: (volume: number) => void;
+  destroy: () => void;
+}
+declare function useAudioPlayer(source: MaybeRef<string>, options?: AudioPlayerOptions): UseAudioPlayerResult; //#endregion
+export { AudioPlayerOptions, BufferedRange, useAudioPlayer };

package/lib/client/composables/audio.js

@@ -1,185 +1,173 @@
-// src/client/composables/audio.ts
 import { onMounted, onUnmounted, ref, toValue, watch } from "vue";
-var mimeTypes = {
-  "audio/flac": ["flac", "fla"],
-  "audio/mpeg": ["mp3", "mpga"],
-  "audio/mp4": ["mp4", "m4a"],
-  "audio/ogg": ["ogg", "oga"],
-  "audio/aac": ["aac", "adts"],
-  "audio/x-ms-wma": ["wma"],
-  "audio/x-aiff": ["aiff", "aif", "aifc"],
-  "audio/webm": ["webm"]
+
+//#region src/client/composables/audio.ts
+const mimeTypes = {
+	"audio/flac": ["flac", "fla"],
+	"audio/mpeg": ["mp3", "mpga"],
+	"audio/mp4": ["mp4", "m4a"],
+	"audio/ogg": ["ogg", "oga"],
+	"audio/aac": ["aac", "adts"],
+	"audio/x-ms-wma": ["wma"],
+	"audio/x-aiff": [
+		"aiff",
+		"aif",
+		"aifc"
+	],
+	"audio/webm": ["webm"]
 };
-var playerList = [];
+const playerList = [];
 function useAudioPlayer(source, options = {}) {
-  let player = null;
-  let unknownSupport = false;
-  const isSupported = ref(false);
-  const loaded = ref(false);
-  const paused = ref(true);
-  const currentTime = ref(0);
-  const duration = ref(0);
-  const volume = ref(1);
-  function initialize() {
-    player = document.createElement("audio");
-    player.className = "audio-player";
-    player.style.display = "none";
-    player.preload = options.autoplay ? "auto" : "none";
-    player.autoplay = options.autoplay ?? false;
-    document.body.appendChild(player);
-    playerList.push(player);
-    player.onloadedmetadata = () => {
-      duration.value = player.duration;
-      currentTime.value = player.currentTime;
-      volume.value = player.volume;
-      loaded.value = true;
-    };
-    player.oncanplay = (...args) => {
-      loaded.value = true;
-      if (unknownSupport)
-        isSupported.value = true;
-      options.oncanplay?.bind(player)(...args);
-    };
-    player.onplay = (...args) => {
-      paused.value = false;
-      options.onplay?.bind(player)(...args);
-    };
-    player.onpause = (...args) => {
-      paused.value = true;
-      options.onpause?.bind(player)(...args);
-    };
-    player.ontimeupdate = () => {
-      if (isValidDuration(player.duration)) {
-        const lastBufferTime = getLastBufferedTime();
-        if (lastBufferTime <= player.duration) {
-          options.ontimeupdate?.bind(player)(lastBufferTime);
-          currentTime.value = lastBufferTime;
-          options.onprogress?.bind(player)(lastBufferTime, player.duration);
-        }
-      }
-    };
-    player.onvolumechange = () => {
-      volume.value = player.volume;
-      options.onvolume?.bind(player)(player.volume);
-    };
-    player.onended = (...args) => {
-      paused.value = true;
-      options.onend?.bind(player)(...args);
-    };
-    player.onplaying = options.onplaying;
-    player.onload = options.onload;
-    player.onerror = options.onerror;
-    player.onseeked = options.onseeked;
-    player.oncanplaythrough = options.oncanplaythrough;
-    player.onwaiting = options.onwaiting;
-    isSupported.value = isSupportType();
-    player.src = toValue(source);
-    player.load();
-  }
-  function isSupportType() {
-    if (!player)
-      return false;
-    let type = toValue(options.type);
-    if (!type) {
-      const ext = toValue(source).split(".").pop() || "";
-      type = Object.keys(mimeTypes).filter((type2) => mimeTypes[type2].includes(ext))[0];
-    }
-    if (!type) {
-      unknownSupport = true;
-      return false;
-    }
-    const isSupported2 = player.canPlayType(type) !== "";
-    if (!isSupported2) {
-      console.warn(`The specified type "${type}" is not supported by the browser.`);
-    }
-    return isSupported2;
-  }
-  function getBufferedRanges() {
-    if (!player)
-      return [];
-    const ranges = [];
-    const seekable = player.buffered || [];
-    const offset = 0;
-    for (let i = 0, length = seekable.length; i < length; i++) {
-      let start = seekable.start(i);
-      let end = seekable.end(i);
-      if (!isValidDuration(start))
-        start = 0;
-      if (!isValidDuration(end)) {
-        end = 0;
-        continue;
-      }
-      ranges.push({
-        start: start + offset,
-        end: end + offset
-      });
-    }
-    return ranges;
-  }
-  function getLastBufferedTime() {
-    const bufferedRanges = getBufferedRanges();
-    if (!bufferedRanges.length)
-      return 0;
-    const buff = bufferedRanges.find(
-      (buff2) => buff2.start < player.currentTime && buff2.end > player.currentTime
-    );
-    if (buff)
-      return buff.end;
-    const last = bufferedRanges[bufferedRanges.length - 1];
-    return last.end;
-  }
-  function isValidDuration(duration2) {
-    if (duration2 && !Number.isNaN(duration2) && duration2 !== Number.POSITIVE_INFINITY && duration2 !== Number.NEGATIVE_INFINITY) {
-      return true;
-    }
-    return false;
-  }
-  function destroy() {
-    player?.pause();
-    player?.remove();
-    playerList.splice(playerList.indexOf(player), 1);
-    player = null;
-  }
-  onMounted(() => {
-    initialize();
-    watch([source, options.type], () => {
-      destroy();
-      loaded.value = false;
-      paused.value = true;
-      currentTime.value = 0;
-      duration.value = 0;
-      initialize();
-    });
-  });
-  onUnmounted(() => destroy());
-  return {
-    isSupported,
-    paused,
-    loaded,
-    currentTime,
-    duration,
-    player,
-    destroy,
-    play: () => {
-      if (options.mutex ?? true) {
-        for (const p of playerList) {
-          if (p !== player)
-            p.pause();
-        }
-      }
-      player?.play();
-    },
-    pause: () => player?.pause(),
-    seek(time) {
-      if (player)
-        player.currentTime = time;
-    },
-    setVolume(volume2) {
-      if (player)
-        player.volume = Math.min(1, Math.max(0, volume2));
-    }
-  };
+	let player = null;
+	let unknownSupport = false;
+	const isSupported = ref(false);
+	const loaded = ref(false);
+	const paused = ref(true);
+	const currentTime = ref(0);
+	const duration = ref(0);
+	const volume = ref(1);
+	function initialize() {
+		player = document.createElement("audio");
+		player.className = "audio-player";
+		player.style.display = "none";
+		player.preload = options.autoplay ? "auto" : "none";
+		player.autoplay = options.autoplay ?? false;
+		document.body.appendChild(player);
+		playerList.push(player);
+		player.onloadedmetadata = () => {
+			duration.value = player.duration;
+			currentTime.value = player.currentTime;
+			volume.value = player.volume;
+			loaded.value = true;
+		};
+		player.oncanplay = (...args) => {
+			loaded.value = true;
+			if (unknownSupport) isSupported.value = true;
+			options.oncanplay?.bind(player)(...args);
+		};
+		player.onplay = (...args) => {
+			paused.value = false;
+			options.onplay?.bind(player)(...args);
+		};
+		player.onpause = (...args) => {
+			paused.value = true;
+			options.onpause?.bind(player)(...args);
+		};
+		player.ontimeupdate = () => {
+			if (isValidDuration(player.duration)) {
+				const lastBufferTime = getLastBufferedTime();
+				if (lastBufferTime <= player.duration) {
+					options.ontimeupdate?.bind(player)(lastBufferTime);
+					currentTime.value = lastBufferTime;
+					options.onprogress?.bind(player)(lastBufferTime, player.duration);
+				}
+			}
+		};
+		player.onvolumechange = () => {
+			volume.value = player.volume;
+			options.onvolume?.bind(player)(player.volume);
+		};
+		player.onended = (...args) => {
+			paused.value = true;
+			options.onend?.bind(player)(...args);
+		};
+		player.onplaying = options.onplaying;
+		player.onload = options.onload;
+		player.onerror = options.onerror;
+		player.onseeked = options.onseeked;
+		player.oncanplaythrough = options.oncanplaythrough;
+		player.onwaiting = options.onwaiting;
+		isSupported.value = isSupportType();
+		player.src = toValue(source);
+		player.load();
+	}
+	function isSupportType() {
+		if (!player) return false;
+		let type = toValue(options.type);
+		if (!type) {
+			const ext = toValue(source).split(".").pop() || "";
+			type = Object.keys(mimeTypes).filter((type$1) => mimeTypes[type$1].includes(ext))[0];
+		}
+		if (!type) {
+			unknownSupport = true;
+			return false;
+		}
+		const isSupported$1 = player.canPlayType(type) !== "";
+		if (!isSupported$1) console.warn(`The specified type "${type}" is not supported by the browser.`);
+		return isSupported$1;
+	}
+	function getBufferedRanges() {
+		if (!player) return [];
+		const ranges = [];
+		const seekable = player.buffered || [];
+		const offset = 0;
+		for (let i = 0, length = seekable.length; i < length; i++) {
+			let start = seekable.start(i);
+			let end = seekable.end(i);
+			if (!isValidDuration(start)) start = 0;
+			if (!isValidDuration(end)) {
+				end = 0;
+				continue;
+			}
+			ranges.push({
+				start: start + offset,
+				end: end + offset
+			});
+		}
+		return ranges;
+	}
+	function getLastBufferedTime() {
+		const bufferedRanges = getBufferedRanges();
+		if (!bufferedRanges.length) return 0;
+		const buff = bufferedRanges.find((buff$1) => buff$1.start < player.currentTime && buff$1.end > player.currentTime);
+		if (buff) return buff.end;
+		const last = bufferedRanges[bufferedRanges.length - 1];
+		return last.end;
+	}
+	function isValidDuration(duration$1) {
+		if (duration$1 && !Number.isNaN(duration$1) && duration$1 !== Number.POSITIVE_INFINITY && duration$1 !== Number.NEGATIVE_INFINITY) return true;
+		return false;
+	}
+	function destroy() {
+		player?.pause();
+		player?.remove();
+		playerList.splice(playerList.indexOf(player), 1);
+		player = null;
+	}
+	onMounted(() => {
+		initialize();
+		watch([source, options.type], () => {
+			destroy();
+			loaded.value = false;
+			paused.value = true;
+			currentTime.value = 0;
+			duration.value = 0;
+			initialize();
+		});
+	});
+	onUnmounted(() => destroy());
+	return {
+		isSupported,
+		paused,
+		loaded,
+		currentTime,
+		duration,
+		player,
+		destroy,
+		play: () => {
+			if (options.mutex ?? true) {
+				for (const p of playerList) if (p !== player) p.pause();
+			}
+			player?.play();
+		},
+		pause: () => player?.pause(),
+		seek(time) {
+			if (player) player.currentTime = time;
+		},
+		setVolume(volume$1) {
+			if (player) player.volume = Math.min(1, Math.max(0, volume$1));
+		}
+	};
 }
-export {
-  useAudioPlayer
-};
+
+//#endregion
+export { useAudioPlayer };

package/lib/client/composables/codeRepl.d.ts

@@ -1,22 +1,25 @@
-import { Ref } from 'vue';
+import { Ref } from "vue";
 
-type Lang = 'kotlin' | 'go' | 'rust';
+//#region src/client/composables/codeRepl.d.ts
+type Lang = "kotlin" | "go" | "rust";
 declare function resolveCode(el: HTMLElement): string;
 declare function resolveCodeInfo(el: HTMLDivElement): {
-    lang: Lang;
-    code: string;
-};
-declare function useCodeRepl(el: Ref<HTMLDivElement | null>): {
-    onRunCode: () => Promise<void>;
-    onCleanRun: () => void;
-    lang: Ref<Lang | undefined, Lang | undefined>;
-    backendVersion: Ref<string, string>;
-    firstRun: Ref<boolean, boolean>;
-    stderr: Ref<string[], string[]>;
-    stdout: Ref<string[], string[]>;
-    loaded: Ref<boolean, boolean>;
-    finished: Ref<boolean, boolean>;
-    error: Ref<string, string>;
+  lang: Lang;
+  code: string;
 };
+interface UseCodeReplResult {
+  lang: Ref<Lang | undefined>;
+  loaded: Ref<boolean>;
+  firstRun: Ref<boolean>;
+  finished: Ref<boolean>;
+  stdout: Ref<string[]>;
+  stderr: Ref<string[]>;
+  error: Ref<string>;
+  backendVersion: Ref<string>;
+  onCleanRun: () => void;
+  onRunCode: () => Promise<void>;
+}
+declare function useCodeRepl(el: Ref<HTMLDivElement | null>): UseCodeReplResult;
 
-export { resolveCode, resolveCodeInfo, useCodeRepl };
+//#endregion
+export { resolveCode, resolveCodeInfo, useCodeRepl };