ai-cli 0.1.1 → 0.2.1

package/src/lib/kitty.ts

@@ -1,55 +0,0 @@
-const SUPPORTED_TERMS = new Set(["xterm-kitty"]);
-
-const SUPPORTED_TERM_PROGRAMS = new Set([
-  "kitty",
-  "ghostty",
-  "wezterm",
-  "warpterminal",
-]);
-
-export function supportsKittyGraphics(): boolean {
-  if (process.env.AI_CLI_PREVIEW === "0") return false;
-  if (process.env.AI_CLI_PREVIEW === "1") return true;
-
-  const term = process.env.TERM ?? "";
-  if (SUPPORTED_TERMS.has(term)) return true;
-
-  const termProgram = (process.env.TERM_PROGRAM ?? "").toLowerCase();
-  if (SUPPORTED_TERM_PROGRAMS.has(termProgram)) return true;
-
-  const lcTerminal = (process.env.LC_TERMINAL ?? "").toLowerCase();
-  if (lcTerminal === "iterm2") return true;
-
-  return false;
-}
-
-import { decodeIDR } from "./h264-wasm.js";
-import { extractKeyframe } from "./mp4.js";
-import { encodePNG } from "./png.js";
-
-const CHUNK_SIZE = 4096;
-
-export async function displayVideoFrame(buf: Buffer): Promise<void> {
-  try {
-    const kf = extractKeyframe(new Uint8Array(buf));
-    if (!kf) return;
-    const frame = await decodeIDR(kf.sps, kf.pps, kf.sliceData);
-    if (!frame) return;
-    const png = encodePNG(frame.yuv, frame.width, frame.height);
-    displayImage(png);
-  } catch {
-    // Preview is best-effort; skip silently on any failure
-  }
-}
-
-export function displayImage(buf: Buffer): void {
-  const encoded = buf.toString("base64");
-  for (let i = 0; i < encoded.length; i += CHUNK_SIZE) {
-    const chunk = encoded.slice(i, i + CHUNK_SIZE);
-    const isLast = i + CHUNK_SIZE >= encoded.length;
-    const control =
-      i === 0 ? `a=T,f=100,m=${isLast ? 0 : 1}` : `m=${isLast ? 0 : 1}`;
-    process.stderr.write(`\x1b_G${control};${chunk}\x1b\\`);
-  }
-  process.stderr.write("\n");
-}

package/src/lib/models.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-import {
-  resolveModels,
-  fetchGatewayModels,
-  FALLBACK_TEXT_MODELS,
-  FALLBACK_IMAGE_MODELS,
-  FALLBACK_VIDEO_MODELS,
-} from "./models.js";
-
-describe("resolveModels", () => {
-  test("returns default when no user model", () => {
-    expect(resolveModels("text")[0]).toContain("/");
-    expect(resolveModels("image")[0]).toContain("/");
-    expect(resolveModels("video")[0]).toContain("/");
-  });
-
-  test("returns fully-qualified model as-is", () => {
-    expect(resolveModels("text", "openai/gpt-4")).toEqual(["openai/gpt-4"]);
-    expect(resolveModels("image", "openai/gpt-image-1")).toEqual([
-      "openai/gpt-image-1",
-    ]);
-  });
-
-  test("expands short image model names", () => {
-    expect(resolveModels("image", "gpt-image-1")).toEqual([
-      "openai/gpt-image-1",
-    ]);
-    expect(resolveModels("image", "flux-2-pro")).toEqual(["bfl/flux-2-pro"]);
-  });
-
-  test("expands short video model names", () => {
-    expect(resolveModels("video", "seedance-2.0")).toEqual([
-      "bytedance/seedance-2.0",
-    ]);
-  });
-
-  test("expands short text model names", () => {
-    expect(resolveModels("text", "gpt-5.5")).toEqual(["openai/gpt-5.5"]);
-    expect(resolveModels("text", "o3")).toEqual(["openai/o3"]);
-  });
-
-  test("returns unknown short names as-is for text", () => {
-    expect(resolveModels("text", "gpt-image-1")).toEqual(["gpt-image-1"]);
-    expect(resolveModels("text", "my-model")).toEqual(["my-model"]);
-  });
-
-  test("returns unknown short names as-is for image/video", () => {
-    expect(resolveModels("image", "nonexistent-model")).toEqual([
-      "nonexistent-model",
-    ]);
-  });
-});
-
-describe("resolveModels multi", () => {
-  test("returns default when no user model", () => {
-    const result = resolveModels("text");
-    expect(result).toHaveLength(1);
-    expect(result[0]).toContain("/");
-  });
-
-  test("splits comma-separated models", () => {
-    const result = resolveModels("image", "openai/gpt-image-1,bfl/flux-2-pro");
-    expect(result).toEqual(["openai/gpt-image-1", "bfl/flux-2-pro"]);
-  });
-
-  test("trims whitespace around model names", () => {
-    const result = resolveModels(
-      "image",
-      "openai/gpt-image-1 , bfl/flux-2-pro"
-    );
-    expect(result).toEqual(["openai/gpt-image-1", "bfl/flux-2-pro"]);
-  });
-
-  test("expands short names in comma list", () => {
-    const result = resolveModels("image", "gpt-image-1,flux-2-pro");
-    expect(result).toEqual(["openai/gpt-image-1", "bfl/flux-2-pro"]);
-  });
-
-  test("filters empty segments from trailing comma", () => {
-    const result = resolveModels("image", "openai/gpt-image-1,");
-    expect(result).toEqual(["openai/gpt-image-1"]);
-  });
-
-  test("falls back to default when all segments are empty", () => {
-    const result = resolveModels("image", ",,,");
-    expect(result).toHaveLength(1);
-    expect(result[0]).toContain("/");
-  });
-});
-
-describe("fetchGatewayModels", () => {
-  test("partitions models by modelType", async () => {
-    const { gateway } = await import("ai");
-    const original = gateway.getAvailableModels;
-    gateway.getAvailableModels = mock(() =>
-      Promise.resolve({
-        models: [
-          { id: "openai/gpt-5", name: "GPT 5", modelType: "language" },
-          {
-            id: "openai/gpt-image-2",
-            name: "GPT Image 2",
-            description: "Image gen",
-            modelType: "image",
-          },
-          { id: "google/veo-3.0", name: "Veo 3", modelType: "video" },
-          {
-            id: "openai/text-embedding-3",
-            name: "Embedding",
-            modelType: "embedding",
-          },
-        ],
-      })
-    ) as unknown as typeof gateway.getAvailableModels;
-
-    try {
-      const result = await fetchGatewayModels();
-
-      expect(result.text).toEqual([
-        { id: "openai/gpt-5", name: "GPT 5", description: undefined },
-      ]);
-      expect(result.image).toEqual([
-        {
-          id: "openai/gpt-image-2",
-          name: "GPT Image 2",
-          description: "Image gen",
-        },
-      ]);
-      expect(result.video).toEqual([
-        { id: "google/veo-3.0", name: "Veo 3", description: undefined },
-      ]);
-    } finally {
-      gateway.getAvailableModels = original;
-    }
-  });
-
-  test("falls back to static lists on gateway error", async () => {
-    const { gateway } = await import("ai");
-    const original = gateway.getAvailableModels;
-    gateway.getAvailableModels = mock(() =>
-      Promise.reject(new Error("network error"))
-    ) as typeof gateway.getAvailableModels;
-
-    try {
-      const result = await fetchGatewayModels();
-
-      expect(result.text.map((m) => m.id)).toEqual(FALLBACK_TEXT_MODELS);
-      expect(result.image.map((m) => m.id)).toEqual(FALLBACK_IMAGE_MODELS);
-      expect(result.video.map((m) => m.id)).toEqual(FALLBACK_VIDEO_MODELS);
-    } finally {
-      gateway.getAvailableModels = original;
-    }
-  });
-
-  test("uses fallbacks when gateway returns no image/video models", async () => {
-    const { gateway } = await import("ai");
-    const original = gateway.getAvailableModels;
-    gateway.getAvailableModels = mock(() =>
-      Promise.resolve({
-        models: [{ id: "openai/gpt-5", name: "GPT 5", modelType: "language" }],
-      })
-    ) as unknown as typeof gateway.getAvailableModels;
-
-    try {
-      const result = await fetchGatewayModels();
-
-      expect(result.text).toHaveLength(1);
-      expect(result.text[0].id).toBe("openai/gpt-5");
-      expect(result.image.map((m) => m.id)).toEqual(FALLBACK_IMAGE_MODELS);
-      expect(result.video.map((m) => m.id)).toEqual(FALLBACK_VIDEO_MODELS);
-    } finally {
-      gateway.getAvailableModels = original;
-    }
-  });
-
-  test("uses text fallbacks when gateway returns no text models", async () => {
-    const { gateway } = await import("ai");
-    const original = gateway.getAvailableModels;
-    gateway.getAvailableModels = mock(() =>
-      Promise.resolve({
-        models: [
-          { id: "openai/gpt-image-2", name: "GPT Image 2", modelType: "image" },
-        ],
-      })
-    ) as unknown as typeof gateway.getAvailableModels;
-
-    try {
-      const result = await fetchGatewayModels();
-
-      expect(result.text.map((m) => m.id)).toEqual(FALLBACK_TEXT_MODELS);
-      expect(result.image).toHaveLength(1);
-      expect(result.video.map((m) => m.id)).toEqual(FALLBACK_VIDEO_MODELS);
-    } finally {
-      gateway.getAvailableModels = original;
-    }
-  });
-});

package/src/lib/models.ts

@@ -1,163 +0,0 @@
-import { gateway } from "ai";
-
-export type Modality = "text" | "image" | "video";
-
-const DEFAULTS: Record<Modality, string> = {
-  text: process.env.AI_CLI_TEXT_MODEL ?? "openai/gpt-5.5",
-  image: process.env.AI_CLI_IMAGE_MODEL ?? "openai/gpt-image-2",
-  video: process.env.AI_CLI_VIDEO_MODEL ?? "bytedance/seedance-2.0",
-};
-
-export const FALLBACK_TEXT_MODELS = [
-  "anthropic/claude-sonnet-4",
-  "google/gemini-2.5-pro",
-  "meta/llama-4-maverick",
-  "openai/gpt-4.1",
-  "openai/gpt-4.1-mini",
-  "openai/gpt-4.1-nano",
-  "openai/gpt-5.5",
-  "openai/o3",
-  "openai/o4-mini",
-  "xai/grok-3",
-];
-
-export const FALLBACK_IMAGE_MODELS = [
-  "bfl/flux-2-flex",
-  "bfl/flux-2-klein-4b",
-  "bfl/flux-2-klein-9b",
-  "bfl/flux-2-max",
-  "bfl/flux-2-pro",
-  "bfl/flux-kontext-max",
-  "bfl/flux-kontext-pro",
-  "bfl/flux-pro-1.0-fill",
-  "bfl/flux-pro-1.1",
-  "bfl/flux-pro-1.1-ultra",
-  "bytedance/seedream-4.0",
-  "bytedance/seedream-4.5",
-  "bytedance/seedream-5.0-lite",
-  "google/imagen-4.0-fast-generate-001",
-  "google/imagen-4.0-generate-001",
-  "google/imagen-4.0-ultra-generate-001",
-  "openai/gpt-image-1",
-  "openai/gpt-image-1-mini",
-  "openai/gpt-image-1.5",
-  "openai/gpt-image-2",
-  "prodia/flux-fast-schnell",
-  "recraft/recraft-v2",
-  "recraft/recraft-v3",
-  "recraft/recraft-v4",
-  "recraft/recraft-v4-pro",
-  "xai/grok-imagine-image",
-  "xai/grok-imagine-image-pro",
-];
-
-export const FALLBACK_VIDEO_MODELS = [
-  "alibaba/wan-v2.5-t2v-preview",
-  "alibaba/wan-v2.6-i2v",
-  "alibaba/wan-v2.6-i2v-flash",
-  "alibaba/wan-v2.6-r2v",
-  "alibaba/wan-v2.6-r2v-flash",
-  "alibaba/wan-v2.6-t2v",
-  "bytedance/seedance-2.0",
-  "bytedance/seedance-2.0-fast",
-  "bytedance/seedance-v1.0-lite-i2v",
-  "bytedance/seedance-v1.0-lite-t2v",
-  "bytedance/seedance-v1.0-pro",
-  "bytedance/seedance-v1.0-pro-fast",
-  "bytedance/seedance-v1.5-pro",
-  "google/veo-3.0-fast-generate-001",
-  "google/veo-3.0-generate-001",
-  "google/veo-3.1-fast-generate-001",
-  "google/veo-3.1-generate-001",
-  "klingai/kling-v2.5-turbo-i2v",
-  "klingai/kling-v2.5-turbo-t2v",
-  "klingai/kling-v2.6-i2v",
-  "klingai/kling-v2.6-motion-control",
-  "klingai/kling-v2.6-t2v",
-  "klingai/kling-v3.0-i2v",
-  "klingai/kling-v3.0-t2v",
-  "xai/grok-imagine-video",
-];
-
-export interface ModelEntry {
-  id: string;
-  name?: string;
-  description?: string;
-}
-
-export interface GatewayModels {
-  text: ModelEntry[];
-  image: ModelEntry[];
-  video: ModelEntry[];
-}
-
-const MODEL_TYPE_TO_MODALITY: Record<string, Modality> = {
-  language: "text",
-  image: "image",
-  video: "video",
-};
-
-export async function fetchGatewayModels(): Promise<GatewayModels> {
-  const result: GatewayModels = { text: [], image: [], video: [] };
-
-  try {
-    const { models } = await gateway.getAvailableModels();
-    for (const m of models) {
-      const modality =
-        MODEL_TYPE_TO_MODALITY[(m as { modelType?: string }).modelType ?? ""];
-      if (!modality) continue;
-      result[modality].push({
-        id: m.id,
-        name: m.name,
-        description: m.description ?? undefined,
-      });
-    }
-  } catch {
-    result.text = FALLBACK_TEXT_MODELS.map((id) => ({ id }));
-    result.image = FALLBACK_IMAGE_MODELS.map((id) => ({ id }));
-    result.video = FALLBACK_VIDEO_MODELS.map((id) => ({ id }));
-  }
-
-  if (result.text.length === 0) {
-    result.text = FALLBACK_TEXT_MODELS.map((id) => ({ id }));
-  }
-  if (result.image.length === 0) {
-    result.image = FALLBACK_IMAGE_MODELS.map((id) => ({ id }));
-  }
-  if (result.video.length === 0) {
-    result.video = FALLBACK_VIDEO_MODELS.map((id) => ({ id }));
-  }
-
-  return result;
-}
-
-function expandModelId(input: string, modality: Modality): string {
-  if (input.includes("/")) return input;
-
-  const knownLists: string[][] = [];
-  if (modality === "text") knownLists.push(FALLBACK_TEXT_MODELS);
-  else if (modality === "image") knownLists.push(FALLBACK_IMAGE_MODELS);
-  else if (modality === "video") knownLists.push(FALLBACK_VIDEO_MODELS);
-
-  for (const list of knownLists) {
-    for (const fullId of list) {
-      const name = fullId.slice(fullId.indexOf("/") + 1);
-      if (name === input) return fullId;
-    }
-  }
-
-  return input;
-}
-
-export function resolveModels(
-  modality: Modality,
-  userModel?: string
-): string[] {
-  if (!userModel) return [DEFAULTS[modality]];
-  const models = userModel
-    .split(",")
-    .map((m) => m.trim())
-    .filter(Boolean)
-    .map((m) => expandModelId(m, modality));
-  return models.length > 0 ? models : [DEFAULTS[modality]];
-}

package/src/lib/mp4.test.ts

@@ -1,231 +0,0 @@
-import { describe, test, expect } from "bun:test";
-
-import { extractKeyframe } from "./mp4.js";
-
-describe("extractKeyframe", () => {
-  test("returns null for empty buffer", () => {
-    expect(extractKeyframe(new Uint8Array(0))).toBeNull();
-  });
-
-  test("returns null for buffer too small", () => {
-    expect(extractKeyframe(new Uint8Array(4))).toBeNull();
-  });
-
-  test("returns null when no moov box found", () => {
-    // Valid-looking box header but wrong type
-    const buf = new Uint8Array(16);
-    const view = new DataView(buf.buffer);
-    view.setUint32(0, 16);
-    buf[4] = 0x66;
-    buf[5] = 0x74;
-    buf[6] = 0x79;
-    buf[7] = 0x70; // ftyp
-    expect(extractKeyframe(buf)).toBeNull();
-  });
-
-  test("returns null for minimal moov with no video track", () => {
-    // Construct a minimal moov box with no trak inside
-    const moovPayload = new Uint8Array(0);
-    const moovSize = 8 + moovPayload.length;
-    const buf = new Uint8Array(moovSize);
-    const view = new DataView(buf.buffer);
-    view.setUint32(0, moovSize);
-    buf[4] = 0x6d;
-    buf[5] = 0x6f;
-    buf[6] = 0x6f;
-    buf[7] = 0x76; // moov
-    expect(extractKeyframe(buf)).toBeNull();
-  });
-
-  test("builds a minimal MP4 structure and extracts keyframe data", () => {
-    // This test creates a valid-ish MP4 structure to exercise the parsing path.
-    // The actual H.264 data is minimal/dummy, so we just verify the parser
-    // successfully extracts SPS, PPS, and slice data.
-    const mp4 = buildMinimalMP4();
-    const result = extractKeyframe(mp4);
-
-    // If the MP4 was well-formed enough, we should get non-null result
-    if (result) {
-      expect(result.sps.length).toBeGreaterThan(0);
-      expect(result.pps.length).toBeGreaterThan(0);
-      expect(result.sliceData.length).toBeGreaterThan(0);
-    }
-  });
-});
-
-function writeBox(type: string, payload: Uint8Array): Uint8Array {
-  const size = 8 + payload.length;
-  const buf = new Uint8Array(size);
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  view.setUint32(0, size);
-  for (let i = 0; i < 4; i++) buf[4 + i] = type.charCodeAt(i);
-  buf.set(payload, 8);
-  return buf;
-}
-
-function concatArrays(...arrs: Uint8Array[]): Uint8Array {
-  const total = arrs.reduce((s, a) => s + a.length, 0);
-  const result = new Uint8Array(total);
-  let off = 0;
-  for (const a of arrs) {
-    result.set(a, off);
-    off += a.length;
-  }
-  return result;
-}
-
-function buildMinimalMP4(): Uint8Array {
-  // SPS NAL unit (minimal baseline profile, 16x16 resolution)
-  const sps = new Uint8Array([
-    0x67, 0x42, 0x00, 0x0a, 0xe9, 0x40, 0x40, 0x04, 0x00, 0x00, 0x00, 0x04,
-    0x00, 0x00, 0x00, 0xc8, 0x40,
-  ]);
-  const pps = new Uint8Array([0x68, 0xce, 0x38, 0x80]);
-
-  // avcC box
-  const avcCPayload = new Uint8Array([
-    1, // version
-    0x42, // profile
-    0x00, // compat
-    0x0a, // level
-    0xff, // nal length size = 4
-    0xe1, // num SPS = 1
-    // SPS length + data
-    (sps.length >> 8) & 0xff,
-    sps.length & 0xff,
-    ...sps,
-    1, // num PPS = 1
-    (pps.length >> 8) & 0xff,
-    pps.length & 0xff,
-    ...pps,
-  ]);
-  const avcC = writeBox("avcC", avcCPayload);
-
-  // avc1 box: 78 bytes fixed header + avcC child
-  const avc1Fixed = new Uint8Array(78);
-  // data_ref_index at offset 6 = 1
-  avc1Fixed[6] = 0;
-  avc1Fixed[7] = 1;
-  // width at offset 24
-  avc1Fixed[24] = 0;
-  avc1Fixed[25] = 16;
-  // height at offset 26
-  avc1Fixed[26] = 0;
-  avc1Fixed[27] = 16;
-  const avc1Payload = concatArrays(avc1Fixed, avcC);
-  const avc1 = writeBox("avc1", avc1Payload);
-
-  // stsd box: version(4) + entry_count(4) + avc1
-  const stsdInner = new Uint8Array(8);
-  const stsdView = new DataView(stsdInner.buffer);
-  stsdView.setUint32(4, 1); // entry count
-  const stsd = writeBox("stsd", concatArrays(stsdInner, avc1));
-
-  // stsz (1 sample, size 10)
-  const stszPayload = new Uint8Array(12);
-  const stszView = new DataView(stszPayload.buffer);
-  stszView.setUint32(4, 0); // sample_size = variable
-  stszView.setUint32(8, 1); // sample_count = 1
-  const stszEntry = new Uint8Array(4);
-  new DataView(stszEntry.buffer).setUint32(0, 10);
-  const stsz = writeBox("stsz", concatArrays(stszPayload, stszEntry));
-
-  // stsc (1 entry: chunk 1, 1 sample/chunk, sdi 1)
-  const stscPayload = new Uint8Array(16);
-  const stscView = new DataView(stscPayload.buffer);
-  stscView.setUint32(4, 1); // entry count
-  stscView.setUint32(8, 1); // first chunk
-  stscView.setUint32(12, 1); // samples per chunk
-  const stscExtra = new Uint8Array(4);
-  new DataView(stscExtra.buffer).setUint32(0, 1);
-  const stsc = writeBox("stsc", concatArrays(stscPayload, stscExtra));
-
-  // stco (1 chunk offset, will be filled in later)
-  const stcoPayload = new Uint8Array(8);
-  const stcoView = new DataView(stcoPayload.buffer);
-  stcoView.setUint32(4, 1); // entry count
-  // offset will be set after we know the layout
-  const stcoOffsetPos = 8; // position within stco payload for the offset value
-  const stco = writeBox("stco", concatArrays(stcoPayload, new Uint8Array(4)));
-
-  // stss (1 sync sample: sample 1)
-  const stssPayload = new Uint8Array(8);
-  const stssView = new DataView(stssPayload.buffer);
-  stssView.setUint32(4, 1); // entry count
-  const stssSample = new Uint8Array(4);
-  new DataView(stssSample.buffer).setUint32(0, 1);
-  const stss = writeBox("stss", concatArrays(stssPayload, stssSample));
-
-  const stbl = writeBox("stbl", concatArrays(stsd, stsz, stsc, stco, stss));
-  const minf = writeBox("minf", stbl);
-
-  // hdlr box (video handler)
-  const hdlrPayload = new Uint8Array(20);
-  // handler_type at offset 8..11 = "vide"
-  hdlrPayload[8] = 0x76;
-  hdlrPayload[9] = 0x69;
-  hdlrPayload[10] = 0x64;
-  hdlrPayload[11] = 0x65;
-  const hdlr = writeBox("hdlr", hdlrPayload);
-
-  const mdia = writeBox("mdia", concatArrays(hdlr, minf));
-  const trak = writeBox("trak", mdia);
-  const moov = writeBox("moov", trak);
-
-  // mdat with a dummy IDR NAL unit (length-prefixed)
-  const idrNal = new Uint8Array([0x65, 0x88, 0x80, 0x40, 0x00, 0x00]);
-  const mdatPayload = new Uint8Array(4 + idrNal.length);
-  new DataView(mdatPayload.buffer).setUint32(0, idrNal.length);
-  mdatPayload.set(idrNal, 4);
-
-  // ftyp box
-  const ftyp = writeBox(
-    "ftyp",
-    new Uint8Array([
-      0x69,
-      0x73,
-      0x6f,
-      0x6d, // brand: isom
-      0x00,
-      0x00,
-      0x02,
-      0x00, // version
-    ])
-  );
-
-  const mdat = writeBox("mdat", mdatPayload);
-
-  // Calculate chunk offset
-  const mdatOffset = ftyp.length + moov.length + 8; // 8 for mdat header
-  const fullMp4 = concatArrays(ftyp, moov, mdat);
-
-  // Patch the stco chunk offset
-  // We need to find the stco entry in the final buffer and patch it
-  const stcoMarker = findStcoOffset(fullMp4);
-  if (stcoMarker >= 0) {
-    const view = new DataView(
-      fullMp4.buffer,
-      fullMp4.byteOffset,
-      fullMp4.byteLength
-    );
-    view.setUint32(stcoMarker, mdatOffset);
-  }
-
-  return fullMp4;
-}
-
-function findStcoOffset(buf: Uint8Array): number {
-  // Find the stco box and return the position of its first chunk offset entry
-  for (let i = 0; i < buf.length - 12; i++) {
-    if (
-      buf[i] === 0x73 &&
-      buf[i + 1] === 0x74 &&
-      buf[i + 2] === 0x63 &&
-      buf[i + 3] === 0x6f
-    ) {
-      // Found "stco" - the chunk offset entry is at i + 4 (version/flags) + 4 (entry_count) + 4
-      return i + 4 + 8;
-    }
-  }
-  return -1;
-}