akari-video 0.1.19 → 0.1.21

package/vendor/packages/edit-store/lib/internal-model.js

@@ -7,10 +7,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readInternalEdit = readInternalEdit;
 exports.readInternalSources = readInternalSources;
 exports.visualContentEndSeconds = visualContentEndSeconds;
+exports.findCrossTrackLayerEvacuations = findCrossTrackLayerEvacuations;
 exports.projectLegacyEdit = projectLegacyEdit;
 exports.toLegacyTrack = toLegacyTrack;
 exports.derivedLegacyTracks = derivedLegacyTracks;
 const edit_v2_1 = require("./edit-v2");
+const cut_adjacency_1 = require("./cut-adjacency");
 const error_1 = require("./migrate/error");
 /**
  * edit.json v2 を内部表現へ読む。v0/v1 は凍結変換ユニットのみが読む。
@@ -171,6 +173,7 @@ function readV2Internal(raw) {
     // 旧 top-level audio と tracks[] 音声が同居すると、後者に加えてこの fallback も射影される。
     // どちらを優先するかは未裁定なので、旧 fixture の互換挙動を変えず二重計上の可能性を残す。
     addV2AudioItems(tracks, edit.audio, fps, legacyIndexCounters);
+    synthesizeHiddenTransitionHandlesForRender(tracks, fps);
     return {
         output: {
             width: edit.output.width,
@@ -190,6 +193,66 @@ function readV2Internal(raw) {
         }
     };
 }
+/**
+ * render-cut に加え shell プレビューの summary と Web UI の readRenderEdit も
+ * item.declaration を読む。そのため出荷プレビューはこの合成済み実重なりを既存窓として描く。
+ * UI / lint が読む item の at/duration/source と legacy.value は生タイムラインのまま保ち、
+ * 突き合わせ境界の隠れのりしろだけを declaration 上の物理重なりへ合成して既存
+ * xfade/acrossfade と 2 つのプレビューへ渡す。生 cuts を直接読む消費者の隠れのりしろ経路とは
+ * packages/edit-store/test/transition-window-path-equivalence.test.mjs で等価性を固定する。
+ */
+function synthesizeHiddenTransitionHandlesForRender(tracks, fps) {
+    const speedOf = (item) => {
+        const speed = item.declaration.speed;
+        return typeof speed === 'number' && Number.isFinite(speed) && speed > 0 ? speed : 1;
+    };
+    for (const track of tracks) {
+        if (track.lane !== 'visual')
+            continue;
+        const cuts = track.items.filter((item) => item.legacy.collection === 'cuts' && item.source.kind === 'media');
+        for (let index = 0; index + 1 < cuts.length; index++) {
+            const outgoing = cuts[index];
+            const incoming = cuts[index + 1];
+            if ((0, cut_adjacency_1.cutOverlapFrames)({ tlEnd: outgoing.at + outgoing.duration }, { tlStart: incoming.at }, fps) !== 0)
+                continue;
+            const transition = outgoing.declaration.transition_out;
+            if (!isRecord(transition)
+                || typeof transition.duration !== 'number'
+                || !Number.isFinite(transition.duration)
+                || transition.duration <= 0)
+                continue;
+            const incomingSpeed = speedOf(incoming);
+            const incomingStill = (0, cut_adjacency_1.isStillImageSourcePath)(incoming.source.path);
+            const plan = (0, cut_adjacency_1.planTransitionHandleWindow)({
+                declaredSeconds: transition.duration,
+                outgoingTailRoomSeconds: Number.POSITIVE_INFINITY,
+                incomingHeadRoomSeconds: incomingStill
+                    ? Number.POSITIVE_INFINITY : incoming.source.in / incomingSpeed,
+                outgoingDurationSeconds: outgoing.duration,
+                incomingDurationSeconds: incoming.duration
+            });
+            if (plan.effectiveSeconds <= 0)
+                continue;
+            const outgoingSpeed = speedOf(outgoing);
+            outgoing.declaration = {
+                ...outgoing.declaration,
+                out: Number(outgoing.declaration.out) + plan.halfSeconds * outgoingSpeed,
+                transition_out: { ...transition, duration: plan.effectiveSeconds }
+            };
+            incoming.declaration = incomingStill
+                ? {
+                    ...incoming.declaration,
+                    at: Number(incoming.declaration.at) - plan.halfSeconds,
+                    out: Number(incoming.declaration.out) + plan.halfSeconds * incomingSpeed
+                }
+                : {
+                    ...incoming.declaration,
+                    at: Number(incoming.declaration.at) - plan.halfSeconds,
+                    in: Number(incoming.declaration.in) - plan.halfSeconds * incomingSpeed
+                };
+        }
+    }
+}
 function legacyKindOfV2Track(track, chromaKeyOf, overlappingItemIds) {
     if (!('items' in track)) {
         return 'captions';
@@ -258,26 +321,16 @@ function needsLayersEngine(item, chromaKeyOf, hasOverlappingSibling = false) {
         return true;
     return false;
 }
-// P0 2026-08-23 cuts-cross-track-overlap: 'cuts' 経路は同一トラック内の同時表示だけでなく、
-// 別トラック間の同時表示も winner-take-all になり、下段を描画できない。全 visual トラックの
-// items[] を総当りで比較し、半開区間 [at, at+duration) が正の長さで交差する media アイテムを
-// layers へ退避する。終端と開始が接するだけなら交差ではない。同一トラックの交差は両方を
-// layers へ送る。別トラックの交差は、下段を cuts の不透明な基底として残し、上段が全画面不透明
-// ではない宣言を持つときだけ layers へ送る。上段が全画面不透明なら winner-take-all でも同じ絵に
-// なるため、従来の cuts / track-stack 経路を保つ。
-//
-// transition_out は同一トラックの隣接カットが意図的に作る狭い重なりで、cuts/xfade が表現する。
-// その例外は同一トラックのペアだけに適用する。別トラックとの交差は transition の有無にかかわらず
-// 真の同時表示なので layers へ退避する。
-function computeOverlappingItemIds(itemGroups) {
+function analyzeOverlappingItems(itemGroups) {
     const overlapping = new Set();
-    const entries = itemGroups.flatMap((items, trackIndex) => items.map(item => ({ item, trackIndex })));
+    const crossTrackEvacuations = [];
+    const entries = itemGroups.flatMap((group, trackIndex) => group.items.map(item => ({ item, trackIndex, trackId: group.trackId })));
     for (let i = 0; i < entries.length; i++) {
-        const { item: a, trackIndex: aTrackIndex } = entries[i];
+        const { item: a, trackIndex: aTrackIndex, trackId: aTrackId } = entries[i];
         if (a.source.kind !== 'media')
             continue;
         for (let j = i + 1; j < entries.length; j++) {
-            const { item: b, trackIndex: bTrackIndex } = entries[j];
+            const { item: b, trackIndex: bTrackIndex, trackId: bTrackId } = entries[j];
             if (b.source.kind !== 'media')
                 continue;
             if (!(a.at < b.at + b.duration && b.at < a.at + a.duration))
@@ -291,13 +344,40 @@ function computeOverlappingItemIds(itemGroups) {
                 overlapping.add(b.id);
             }
             else {
-                const upper = aTrackIndex > bTrackIndex ? a : b;
-                if (needsCrossTrackLayers(upper))
+                const upperIsA = aTrackIndex > bTrackIndex;
+                const upper = upperIsA ? a : b;
+                const lower = upperIsA ? b : a;
+                if (needsCrossTrackLayers(upper)) {
                     overlapping.add(upper.id);
+                    crossTrackEvacuations.push({
+                        itemId: upper.id,
+                        trackId: upperIsA ? aTrackId : bTrackId,
+                        causeItemId: lower.id,
+                        causeTrackId: upperIsA ? bTrackId : aTrackId,
+                        overlapStartFrames: Math.max(a.at, b.at),
+                        overlapEndFrames: Math.min(a.at + a.duration, b.at + b.duration)
+                    });
+                }
             }
         }
     }
-    return overlapping;
+    return { itemIds: overlapping, crossTrackEvacuations };
+}
+function computeOverlappingItemIds(itemGroups) {
+    return analyzeOverlappingItems(itemGroups.map((items, index) => ({
+        items,
+        trackId: String(index)
+    }))).itemIds;
+}
+/**
+ * 別 visual track との重なりが原因で upper item が layers へ退避される組を返す。
+ * edit-lint と UI は理由文言に必要な相手 id を、この単一定義から得る。
+ */
+function findCrossTrackLayerEvacuations(edit) {
+    const parsed = (0, edit_v2_1.readEditV2)(edit);
+    return analyzeOverlappingItems(parsed.tracks.flatMap(track => track.lane === 'visual' && 'items' in track
+        ? [{ items: track.items, trackId: track.id }]
+        : [])).crossTrackEvacuations;
 }
 // cuts の winner-take-all が下段を隠してよいのは、上段が全画面を不透明に覆う場合だけ。
 // transform の単位元を明示しただけなら従来経路を維持する。crop / 半透明 / keyframes は、

package/vendor/packages/edit-store/lib/migrate/legacy-parse.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseEdit = parseEdit;
+const transition_vocabulary_1 = require("../transition-vocabulary");
 const LAYER_BLEND_MODES = [
     'normal', 'screen', 'multiply', 'add', 'difference',
     'darken', 'lighten', 'overlay', 'hardlight', 'softlight'
@@ -78,16 +79,18 @@ function parseEdit(source) {
                 let transitionOut;
                 if (rawCut.transition_out !== undefined && rawCut.transition_out !== null) {
                     const transition = rawCut.transition_out;
-                    const validType = transition?.type === 'dissolve'
-                        || transition?.type === 'fade-black'
-                        || transition?.type === 'fade-white'
-                        || transition?.type === 'reveal-down'
-                        || transition?.type === 'reveal-up';
+                    // 正準語彙に加え、手編集で先行した非空文字列も読み取りだけは保持する。
+                    // 書き込み API は isTransitionType で閉じたまま、preview の汎用フォールバックへ渡す。
+                    const validType = (0, transition_vocabulary_1.isTransitionType)(transition?.type)
+                        || (typeof transition?.type === 'string' && transition.type.trim().length > 0);
                     const validDuration = typeof transition?.duration === 'number'
                         && Number.isFinite(transition.duration) && transition.duration > 0;
                     if (transition && typeof transition === 'object' && !Array.isArray(transition)
                         && validType && validDuration) {
-                        transitionOut = { type: transition.type, duration: transition.duration };
+                        transitionOut = {
+                            type: transition.type,
+                            duration: transition.duration
+                        };
                     }
                     else {
                         warnings.push(`${index + 1} 番目のクリップの transition_out が不正なため無視します。`);

package/vendor/packages/edit-store/lib/timeline-map.d.ts

@@ -56,6 +56,11 @@ export interface TimelineMapResult {
 export declare function transitionProgressAt(window: TimelineTransitionWindow, outputT: number): number;
 export declare function buildTimelineMap(cuts: readonly EditCut[], options?: {
     trackZ?: (track: number) => number;
+    fps?: number;
+    handleRoom?: (cutIndex: number) => {
+        tailSeconds?: number;
+        headSeconds?: number;
+    } | undefined;
 }): TimelineMapResult;
 /**
  * 出力秒 → ソース秒。トランジション重なり区間（隣接 src が重なる出力時刻）は

package/vendor/packages/edit-store/lib/timeline-map.js

@@ -16,6 +16,7 @@ exports.transitionProgressAt = transitionProgressAt;
 exports.buildTimelineMap = buildTimelineMap;
 exports.outputToSource = outputToSource;
 const edit_store_1 = require("./edit-store");
+const cut_adjacency_1 = require("./cut-adjacency");
 function transitionProgressAt(window, outputT) {
     if (!(window.duration > 0))
         return 0;
@@ -37,10 +38,49 @@ function buildTimelineMap(cuts, options) {
     const resolved = trackSegments.map(segment => ({
         start: segment.at,
         end: segment.end,
+        baseStart: segment.at,
+        baseEnd: segment.end,
         track: segment.track,
         cut: usableCuts[segment.index],
         cutIndex: usable[segment.index].index
     }));
+    const fps = options?.fps ?? cut_adjacency_1.DEFAULT_CUT_ADJACENCY_FPS;
+    // 隠れのりしろは、フレーム量子化で突き合わせとなる境界にだけ合成する。
+    // 実重なり済みの境界は一切変更せず、従来の窓計算へそのまま流す。
+    for (let outgoingIndex = 0; outgoingIndex < resolved.length; outgoingIndex++) {
+        const outgoing = resolved[outgoingIndex];
+        const transition = outgoing.cut.transitionOut;
+        if (!transition || !(typeof transition.duration === 'number' && Number.isFinite(transition.duration)
+            && transition.duration > 0))
+            continue;
+        const incoming = resolved.slice(outgoingIndex + 1).find(candidate => candidate.track === outgoing.track);
+        if (!incoming || (0, cut_adjacency_1.cutOverlapFrames)({ tlEnd: outgoing.end }, { tlStart: incoming.start }, fps) !== 0)
+            continue;
+        const outgoingRoom = options?.handleRoom?.(outgoing.cutIndex);
+        const incomingRoom = options?.handleRoom?.(incoming.cutIndex);
+        const incomingSpeed = typeof incoming.cut.speed === 'number' && incoming.cut.speed > 0
+            ? incoming.cut.speed : 1;
+        const plan = (0, cut_adjacency_1.planTransitionHandleWindow)({
+            declaredSeconds: transition.duration,
+            outgoingTailRoomSeconds: outgoingRoom?.tailSeconds ?? Number.POSITIVE_INFINITY,
+            incomingHeadRoomSeconds: incomingRoom?.headSeconds ?? incoming.cut.in / incomingSpeed,
+            outgoingDurationSeconds: outgoing.baseEnd - outgoing.baseStart,
+            incomingDurationSeconds: incoming.baseEnd - incoming.baseStart
+        });
+        if (plan.effectiveSeconds <= 0)
+            continue;
+        const cutPoint = outgoing.end;
+        outgoing.end = cutPoint + plan.halfSeconds;
+        outgoing.cut = {
+            ...outgoing.cut,
+            transitionOut: { ...transition, duration: plan.effectiveSeconds }
+        };
+        incoming.start = cutPoint - plan.halfSeconds;
+        incoming.cut = {
+            ...incoming.cut,
+            in: Math.max(0, incoming.cut.in - plan.halfSeconds * incomingSpeed)
+        };
+    }
     const segmentSlice = (entry, start, end, transitionOut = null) => {
         const cut = entry.cut;
         const speed = typeof cut.speed === 'number' && cut.speed > 0 ? cut.speed : 1;

package/vendor/packages/edit-store/lib/transition-vocabulary.d.ts

@@ -0,0 +1,223 @@
+/**
+ * edit.json の transition_out.type に使える正準語彙。
+ * JSON Schema はリテラル enum を保つため別置きだが、drift test でこの表と一致させる。
+ */
+export declare const TRANSITION_VOCABULARY: readonly [{
+    readonly id: "dissolve";
+    readonly xfadeName: "dissolve";
+    readonly labelJa: "ディゾルブ";
+    readonly category: "フェード";
+    readonly previewKind: "dissolve";
+    readonly glyph: "D";
+}, {
+    readonly id: "fade";
+    readonly xfadeName: "fade";
+    readonly labelJa: "クロスフェード";
+    readonly category: "フェード";
+    readonly previewKind: "fade";
+    readonly glyph: "F";
+}, {
+    readonly id: "fade-black";
+    readonly xfadeName: "fadeblack";
+    readonly labelJa: "黒フェード";
+    readonly category: "フェード";
+    readonly previewKind: "fade-black";
+    readonly glyph: "B";
+}, {
+    readonly id: "fade-white";
+    readonly xfadeName: "fadewhite";
+    readonly labelJa: "白フェード";
+    readonly category: "フェード";
+    readonly previewKind: "fade-white";
+    readonly glyph: "W";
+}, {
+    readonly id: "fade-grays";
+    readonly xfadeName: "fadegrays";
+    readonly labelJa: "モノクロフェード";
+    readonly category: "フェード";
+    readonly previewKind: "fade-grays";
+    readonly glyph: "G";
+}, {
+    readonly id: "wipe-left";
+    readonly xfadeName: "wipeleft";
+    readonly labelJa: "ワイプ（左へ）";
+    readonly category: "ワイプ";
+    readonly previewKind: "wipe-left";
+    readonly glyph: "←";
+}, {
+    readonly id: "wipe-right";
+    readonly xfadeName: "wiperight";
+    readonly labelJa: "ワイプ（右へ）";
+    readonly category: "ワイプ";
+    readonly previewKind: "wipe-right";
+    readonly glyph: "→";
+}, {
+    readonly id: "wipe-up";
+    readonly xfadeName: "wipeup";
+    readonly labelJa: "ワイプ（上へ）";
+    readonly category: "ワイプ";
+    readonly previewKind: "wipe-up";
+    readonly glyph: "↑";
+}, {
+    readonly id: "wipe-down";
+    readonly xfadeName: "wipedown";
+    readonly labelJa: "ワイプ（下へ）";
+    readonly category: "ワイプ";
+    readonly previewKind: "wipe-down";
+    readonly glyph: "↓";
+}, {
+    readonly id: "radial";
+    readonly xfadeName: "radial";
+    readonly labelJa: "時計ワイプ";
+    readonly category: "ワイプ";
+    readonly previewKind: "radial";
+    readonly glyph: "◷";
+}, {
+    readonly id: "slide-left";
+    readonly xfadeName: "slideleft";
+    readonly labelJa: "スライド（左へ）";
+    readonly category: "スライド";
+    readonly previewKind: "slide-left";
+    readonly glyph: "←";
+}, {
+    readonly id: "slide-right";
+    readonly xfadeName: "slideright";
+    readonly labelJa: "スライド（右へ）";
+    readonly category: "スライド";
+    readonly previewKind: "slide-right";
+    readonly glyph: "→";
+}, {
+    readonly id: "slide-up";
+    readonly xfadeName: "slideup";
+    readonly labelJa: "スライド（上へ）";
+    readonly category: "スライド";
+    readonly previewKind: "slide-up";
+    readonly glyph: "↑";
+}, {
+    readonly id: "slide-down";
+    readonly xfadeName: "slidedown";
+    readonly labelJa: "スライド（下へ）";
+    readonly category: "スライド";
+    readonly previewKind: "slide-down";
+    readonly glyph: "↓";
+}, {
+    readonly id: "cover-left";
+    readonly xfadeName: "coverleft";
+    readonly labelJa: "カバー（左へ）";
+    readonly category: "カバー";
+    readonly previewKind: "cover-left";
+    readonly glyph: "←";
+}, {
+    readonly id: "cover-right";
+    readonly xfadeName: "coverright";
+    readonly labelJa: "カバー（右へ）";
+    readonly category: "カバー";
+    readonly previewKind: "cover-right";
+    readonly glyph: "→";
+}, {
+    readonly id: "cover-up";
+    readonly xfadeName: "coverup";
+    readonly labelJa: "カバー（上へ）";
+    readonly category: "カバー";
+    readonly previewKind: "cover-up";
+    readonly glyph: "↑";
+}, {
+    readonly id: "cover-down";
+    readonly xfadeName: "coverdown";
+    readonly labelJa: "カバー（下へ）";
+    readonly category: "カバー";
+    readonly previewKind: "cover-down";
+    readonly glyph: "↓";
+}, {
+    readonly id: "reveal-left";
+    readonly xfadeName: "revealleft";
+    readonly labelJa: "リビール（左へ）";
+    readonly category: "リビール";
+    readonly previewKind: "reveal-left";
+    readonly glyph: "←";
+}, {
+    readonly id: "reveal-right";
+    readonly xfadeName: "revealright";
+    readonly labelJa: "リビール（右へ）";
+    readonly category: "リビール";
+    readonly previewKind: "reveal-right";
+    readonly glyph: "→";
+}, {
+    readonly id: "reveal-down";
+    readonly xfadeName: "revealdown";
+    readonly labelJa: "上からリビール";
+    readonly category: "リビール";
+    readonly previewKind: "reveal-down";
+    readonly glyph: "↓";
+}, {
+    readonly id: "reveal-up";
+    readonly xfadeName: "revealup";
+    readonly labelJa: "下からリビール";
+    readonly category: "リビール";
+    readonly previewKind: "reveal-up";
+    readonly glyph: "↑";
+}, {
+    readonly id: "circle-open";
+    readonly xfadeName: "circleopen";
+    readonly labelJa: "サークル（開く）";
+    readonly category: "形状";
+    readonly previewKind: "circle-open";
+    readonly glyph: "○";
+}, {
+    readonly id: "circle-close";
+    readonly xfadeName: "circleclose";
+    readonly labelJa: "サークル（閉じる）";
+    readonly category: "形状";
+    readonly previewKind: "circle-close";
+    readonly glyph: "●";
+}, {
+    readonly id: "zoom-in";
+    readonly xfadeName: "zoomin";
+    readonly labelJa: "ズームイン";
+    readonly category: "変形";
+    readonly previewKind: "zoom-in";
+    readonly glyph: "＋";
+}, {
+    readonly id: "squeeze-h";
+    readonly xfadeName: "squeezeh";
+    readonly labelJa: "スクイーズ（縦つぶし）";
+    readonly category: "変形";
+    readonly previewKind: "squeeze-h";
+    readonly glyph: "↕";
+}, {
+    readonly id: "squeeze-v";
+    readonly xfadeName: "squeezev";
+    readonly labelJa: "スクイーズ（横つぶし）";
+    readonly category: "変形";
+    readonly previewKind: "squeeze-v";
+    readonly glyph: "↔";
+}, {
+    readonly id: "blur";
+    readonly xfadeName: "hblur";
+    readonly labelJa: "ブラー";
+    readonly category: "質感";
+    readonly previewKind: "blur";
+    readonly glyph: "B";
+}, {
+    readonly id: "pixelize";
+    readonly xfadeName: "pixelize";
+    readonly labelJa: "ピクセレート";
+    readonly category: "質感";
+    readonly previewKind: "pixelize";
+    readonly glyph: "P";
+}];
+export type TransitionDefinition = typeof TRANSITION_VOCABULARY[number];
+export type TransitionType = TransitionDefinition['id'];
+export type TransitionCategory = TransitionDefinition['category'];
+export type TransitionPreviewKind = TransitionDefinition['previewKind'];
+declare const unknownTransitionTypeBrand: unique symbol;
+/** 読み取り側だけが保持する、schema より先行した未知種別。書き込み API には使わない。 */
+export type UnknownTransitionType = string & {
+    readonly [unknownTransitionTypeBrand]: true;
+};
+export type ReadableTransitionType = TransitionType | UnknownTransitionType;
+export declare const TRANSITION_TYPE_IDS: readonly TransitionType[];
+export declare const TRANSITION_CATEGORIES: readonly TransitionCategory[];
+export declare const TRANSITION_BY_ID: Readonly<Record<TransitionType, TransitionDefinition>>;
+export declare function isTransitionType(value: unknown): value is TransitionType;
+export {};

package/vendor/packages/edit-store/lib/transition-vocabulary.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSITION_BY_ID = exports.TRANSITION_CATEGORIES = exports.TRANSITION_TYPE_IDS = exports.TRANSITION_VOCABULARY = void 0;
+exports.isTransitionType = isTransitionType;
+/**
+ * edit.json の transition_out.type に使える正準語彙。
+ * JSON Schema はリテラル enum を保つため別置きだが、drift test でこの表と一致させる。
+ */
+exports.TRANSITION_VOCABULARY = [
+    { id: 'dissolve', xfadeName: 'dissolve', labelJa: 'ディゾルブ', category: 'フェード', previewKind: 'dissolve', glyph: 'D' },
+    { id: 'fade', xfadeName: 'fade', labelJa: 'クロスフェード', category: 'フェード', previewKind: 'fade', glyph: 'F' },
+    { id: 'fade-black', xfadeName: 'fadeblack', labelJa: '黒フェード', category: 'フェード', previewKind: 'fade-black', glyph: 'B' },
+    { id: 'fade-white', xfadeName: 'fadewhite', labelJa: '白フェード', category: 'フェード', previewKind: 'fade-white', glyph: 'W' },
+    { id: 'fade-grays', xfadeName: 'fadegrays', labelJa: 'モノクロフェード', category: 'フェード', previewKind: 'fade-grays', glyph: 'G' },
+    { id: 'wipe-left', xfadeName: 'wipeleft', labelJa: 'ワイプ（左へ）', category: 'ワイプ', previewKind: 'wipe-left', glyph: '←' },
+    { id: 'wipe-right', xfadeName: 'wiperight', labelJa: 'ワイプ（右へ）', category: 'ワイプ', previewKind: 'wipe-right', glyph: '→' },
+    { id: 'wipe-up', xfadeName: 'wipeup', labelJa: 'ワイプ（上へ）', category: 'ワイプ', previewKind: 'wipe-up', glyph: '↑' },
+    { id: 'wipe-down', xfadeName: 'wipedown', labelJa: 'ワイプ（下へ）', category: 'ワイプ', previewKind: 'wipe-down', glyph: '↓' },
+    { id: 'radial', xfadeName: 'radial', labelJa: '時計ワイプ', category: 'ワイプ', previewKind: 'radial', glyph: '◷' },
+    { id: 'slide-left', xfadeName: 'slideleft', labelJa: 'スライド（左へ）', category: 'スライド', previewKind: 'slide-left', glyph: '←' },
+    { id: 'slide-right', xfadeName: 'slideright', labelJa: 'スライド（右へ）', category: 'スライド', previewKind: 'slide-right', glyph: '→' },
+    { id: 'slide-up', xfadeName: 'slideup', labelJa: 'スライド（上へ）', category: 'スライド', previewKind: 'slide-up', glyph: '↑' },
+    { id: 'slide-down', xfadeName: 'slidedown', labelJa: 'スライド（下へ）', category: 'スライド', previewKind: 'slide-down', glyph: '↓' },
+    { id: 'cover-left', xfadeName: 'coverleft', labelJa: 'カバー（左へ）', category: 'カバー', previewKind: 'cover-left', glyph: '←' },
+    { id: 'cover-right', xfadeName: 'coverright', labelJa: 'カバー（右へ）', category: 'カバー', previewKind: 'cover-right', glyph: '→' },
+    { id: 'cover-up', xfadeName: 'coverup', labelJa: 'カバー（上へ）', category: 'カバー', previewKind: 'cover-up', glyph: '↑' },
+    { id: 'cover-down', xfadeName: 'coverdown', labelJa: 'カバー（下へ）', category: 'カバー', previewKind: 'cover-down', glyph: '↓' },
+    { id: 'reveal-left', xfadeName: 'revealleft', labelJa: 'リビール（左へ）', category: 'リビール', previewKind: 'reveal-left', glyph: '←' },
+    { id: 'reveal-right', xfadeName: 'revealright', labelJa: 'リビール（右へ）', category: 'リビール', previewKind: 'reveal-right', glyph: '→' },
+    { id: 'reveal-down', xfadeName: 'revealdown', labelJa: '上からリビール', category: 'リビール', previewKind: 'reveal-down', glyph: '↓' },
+    { id: 'reveal-up', xfadeName: 'revealup', labelJa: '下からリビール', category: 'リビール', previewKind: 'reveal-up', glyph: '↑' },
+    { id: 'circle-open', xfadeName: 'circleopen', labelJa: 'サークル（開く）', category: '形状', previewKind: 'circle-open', glyph: '○' },
+    { id: 'circle-close', xfadeName: 'circleclose', labelJa: 'サークル（閉じる）', category: '形状', previewKind: 'circle-close', glyph: '●' },
+    { id: 'zoom-in', xfadeName: 'zoomin', labelJa: 'ズームイン', category: '変形', previewKind: 'zoom-in', glyph: '＋' },
+    { id: 'squeeze-h', xfadeName: 'squeezeh', labelJa: 'スクイーズ（縦つぶし）', category: '変形', previewKind: 'squeeze-h', glyph: '↕' },
+    { id: 'squeeze-v', xfadeName: 'squeezev', labelJa: 'スクイーズ（横つぶし）', category: '変形', previewKind: 'squeeze-v', glyph: '↔' },
+    { id: 'blur', xfadeName: 'hblur', labelJa: 'ブラー', category: '質感', previewKind: 'blur', glyph: 'B' },
+    { id: 'pixelize', xfadeName: 'pixelize', labelJa: 'ピクセレート', category: '質感', previewKind: 'pixelize', glyph: 'P' }
+];
+exports.TRANSITION_TYPE_IDS = exports.TRANSITION_VOCABULARY.map(entry => entry.id);
+exports.TRANSITION_CATEGORIES = [...new Set(exports.TRANSITION_VOCABULARY.map(entry => entry.category))];
+exports.TRANSITION_BY_ID = Object.fromEntries(exports.TRANSITION_VOCABULARY.map(entry => [entry.id, entry]));
+function isTransitionType(value) {
+    return typeof value === 'string' && Object.prototype.hasOwnProperty.call(exports.TRANSITION_BY_ID, value);
+}