prompt-api-polyfill 1.0.0 → 1.1.0

package/dist/prompt-api-polyfill.js

@@ -0,0 +1,1031 @@
+import { Schema as T } from "firebase/ai";
+ReadableStream.prototype[Symbol.asyncIterator] || (ReadableStream.prototype[Symbol.asyncIterator] = async function* () {
+  const l = this.getReader();
+  try {
+    for (; ; ) {
+      const { done: t, value: e } = await l.read();
+      if (t)
+        return;
+      yield e;
+    }
+  } finally {
+    l.releaseLock();
+  }
+});
+class M {
+  static async convert(t, e) {
+    if (t === "image")
+      return this.processImage(e);
+    if (t === "audio")
+      return this.processAudio(e);
+    throw new DOMException(
+      `Unsupported media type: ${t}`,
+      "NotSupportedError"
+    );
+  }
+  static async processImage(t) {
+    if (t instanceof Blob)
+      return this.blobToInlineData(t);
+    if (ArrayBuffer.isView(t) || t instanceof ArrayBuffer) {
+      const e = t instanceof ArrayBuffer ? new Uint8Array(t) : new Uint8Array(t.buffer, t.byteOffset, t.byteLength), r = e.buffer.slice(
+        e.byteOffset,
+        e.byteOffset + e.byteLength
+      ), o = this.arrayBufferToBase64(r), n = this.#o(e);
+      if (!n)
+        throw new DOMException("Invalid image data", "InvalidStateError");
+      return { inlineData: { data: o, mimeType: n } };
+    }
+    return this.canvasSourceToInlineData(t);
+  }
+  static #o(t) {
+    if (t.length < 4)
+      return null;
+    if (t[0] === 255 && t[1] === 216 && t[2] === 255)
+      return "image/jpeg";
+    if (t[0] === 137 && t[1] === 80 && t[2] === 78 && t[3] === 71 && t[4] === 13 && t[5] === 10 && t[6] === 26 && t[7] === 10)
+      return "image/png";
+    if (t[0] === 71 && t[1] === 73 && t[2] === 70 && t[3] === 56)
+      return "image/gif";
+    if (t[0] === 82 && t[1] === 73 && t[2] === 70 && t[3] === 70 && t[8] === 87 && t[9] === 69 && t[10] === 66 && t[11] === 80)
+      return "image/webp";
+    if (t[0] === 66 && t[1] === 77)
+      return "image/bmp";
+    if (t[0] === 0 && t[1] === 0 && t[2] === 1 && t[3] === 0)
+      return "image/x-icon";
+    if (t[0] === 73 && t[1] === 73 && t[2] === 42 || t[0] === 77 && t[1] === 77 && t[2] === 42)
+      return "image/tiff";
+    if (t[4] === 102 && t[5] === 116 && t[6] === 121 && t[7] === 112) {
+      const o = String.fromCharCode(t[8], t[9], t[10], t[11]);
+      if (o === "avif" || o === "avis")
+        return "image/avif";
+      if (o === "heic" || o === "heix" || o === "hevc" || o === "hevx")
+        return "image/heic";
+      if (o === "mif1" || o === "msf1")
+        return "image/heif";
+    }
+    if (t[0] === 255 && t[1] === 10 || t[0] === 0 && t[4] === 74 && t[5] === 88 && t[6] === 76)
+      return "image/jxl";
+    if (t[0] === 0 && t[4] === 106 && t[5] === 80 && t[6] === 32)
+      return "image/jp2";
+    const r = String.fromCharCode(...t.slice(0, 100)).toLowerCase();
+    return r.includes("<svg") || r.includes("<?xml") ? "image/svg+xml" : null;
+  }
+  static async processAudio(t) {
+    if (t instanceof Blob) {
+      if (t.type && !t.type.startsWith("audio/") && t.type !== "application/ogg")
+        throw new DOMException("Invalid audio mime type", "DataError");
+      return this.blobToInlineData(t);
+    }
+    if (t instanceof AudioBuffer) {
+      const o = this.audioBufferToWav(t);
+      return { inlineData: { data: this.arrayBufferToBase64(o), mimeType: "audio/wav" } };
+    }
+    const e = t instanceof ArrayBuffer || t && t.constructor && t.constructor.name === "ArrayBuffer", r = ArrayBuffer.isView(t) || t && t.buffer && (t.buffer instanceof ArrayBuffer || t.buffer.constructor.name === "ArrayBuffer");
+    if (e || r) {
+      const o = e ? t : t.buffer;
+      return {
+        inlineData: {
+          data: this.arrayBufferToBase64(o),
+          mimeType: "audio/wav"
+          // Fallback assumption
+        }
+      };
+    }
+    throw new DOMException("Unsupported audio source", "NotSupportedError");
+  }
+  // Low Level Converters
+  static blobToInlineData(t) {
+    return new Promise((e, r) => {
+      const o = new FileReader();
+      o.onloadend = () => {
+        o.error ? r(o.error) : e({
+          inlineData: {
+            data: o.result.split(",")[1],
+            mimeType: t.type
+          }
+        });
+      }, o.readAsDataURL(t);
+    });
+  }
+  static async canvasSourceToInlineData(t) {
+    typeof HTMLImageElement < "u" && t instanceof HTMLImageElement && !t.complete && await t.decode().catch(() => {
+    });
+    const e = (s) => {
+      const c = t[s];
+      return typeof c == "object" && c !== null && "baseVal" in c ? c.baseVal.value : typeof c == "number" ? c : 0;
+    };
+    let r = t.displayWidth || t.naturalWidth || t.videoWidth || e("width"), o = t.displayHeight || t.naturalHeight || t.videoHeight || e("height");
+    if ((!r || !o) && typeof t.getBBox == "function")
+      try {
+        const s = t.getBBox();
+        r = r || s.width, o = o || s.height;
+      } catch {
+      }
+    if ((!r || !o) && typeof t.getBoundingClientRect == "function")
+      try {
+        const s = t.getBoundingClientRect();
+        r = r || s.width, o = o || s.height;
+      } catch {
+      }
+    if (!r || !o)
+      throw new DOMException("Invalid image dimensions", "InvalidStateError");
+    const n = document.createElement("canvas");
+    n.width = r, n.height = o;
+    const i = n.getContext("2d");
+    return typeof ImageData < "u" && t instanceof ImageData ? i.putImageData(t, 0, 0) : i.drawImage(t, 0, 0), {
+      inlineData: {
+        data: n.toDataURL("image/png").split(",")[1],
+        mimeType: "image/png"
+      }
+    };
+  }
+  static arrayBufferToBase64(t) {
+    let e = "";
+    const r = new Uint8Array(t), o = r.byteLength;
+    for (let n = 0; n < o; n++)
+      e += String.fromCharCode(r[n]);
+    return window.btoa(e);
+  }
+  // Simple WAV Encoder for AudioBuffer
+  static audioBufferToWav(t) {
+    const e = t.numberOfChannels, r = t.sampleRate, o = 1, n = 16;
+    let i;
+    return e === 2 ? i = this.interleave(
+      t.getChannelData(0),
+      t.getChannelData(1)
+    ) : i = t.getChannelData(0), this.encodeWAV(i, o, r, e, n);
+  }
+  static interleave(t, e) {
+    const r = t.length + e.length, o = new Float32Array(r);
+    let n = 0, i = 0;
+    for (; n < r; )
+      o[n++] = t[i], o[n++] = e[i], i++;
+    return o;
+  }
+  static encodeWAV(t, e, r, o, n) {
+    const i = n / 8, a = o * i, s = new ArrayBuffer(44 + t.length * i), c = new DataView(s);
+    return this.writeString(c, 0, "RIFF"), c.setUint32(4, 36 + t.length * i, !0), this.writeString(c, 8, "WAVE"), this.writeString(c, 12, "fmt "), c.setUint32(16, 16, !0), c.setUint16(20, e, !0), c.setUint16(22, o, !0), c.setUint32(24, r, !0), c.setUint32(28, r * a, !0), c.setUint16(32, a, !0), c.setUint16(34, n, !0), this.writeString(c, 36, "data"), c.setUint32(40, t.length * i, !0), this.floatTo16BitPCM(c, 44, t), s;
+  }
+  static floatTo16BitPCM(t, e, r) {
+    for (let o = 0; o < r.length; o++, e += 2) {
+      const n = Math.max(-1, Math.min(1, r[o]));
+      t.setInt16(e, n < 0 ? n * 32768 : n * 32767, !0);
+    }
+  }
+  static writeString(t, e, r) {
+    for (let o = 0; o < r.length; o++)
+      t.setUint8(e + o, r.charCodeAt(o));
+  }
+}
+function v(l) {
+  if (!l)
+    return;
+  const t = {
+    description: l.description,
+    nullable: l.nullable || !1,
+    format: l.format
+  };
+  switch (Array.isArray(l.type) && l.type.includes("null") && (t.nullable = !0, l.type = l.type.find((e) => e !== "null")), l.type) {
+    case "string":
+      return l.enum && Array.isArray(l.enum) ? T.enumString({
+        ...t,
+        enum: l.enum
+      }) : T.string(t);
+    case "number":
+      return T.number(t);
+    case "integer":
+      return T.integer(t);
+    case "boolean":
+      return T.boolean(t);
+    case "array":
+      return T.array({
+        ...t,
+        // Recursively convert the 'items' schema
+        items: v(l.items)
+      });
+    case "object":
+      const e = {}, r = l.properties ? Object.keys(l.properties) : [];
+      r.forEach((i) => {
+        e[i] = v(
+          l.properties[i]
+        );
+      });
+      const o = l.required || [], n = r.filter(
+        (i) => !o.includes(i)
+      );
+      return T.object({
+        ...t,
+        properties: e,
+        optionalProperties: n
+      });
+    default:
+      return console.warn(
+        `Unsupported type: ${l.type}, defaulting to string.`
+      ), T.string(t);
+  }
+}
+async function I(l, t = globalThis) {
+  const e = [];
+  for (const r of l) {
+    const o = r.role === "assistant" ? "model" : "user", n = o === "model";
+    let i = [];
+    if (Array.isArray(r.content))
+      for (const a of r.content)
+        if (a.type === "text") {
+          const s = a.value || a.text || "";
+          if (typeof s != "string")
+            throw new (t.DOMException || globalThis.DOMException)(
+              'The content type "text" must have a string value.',
+              "SyntaxError"
+            );
+          i.push({ text: s });
+        } else {
+          if (n)
+            throw new (t.DOMException || globalThis.DOMException)(
+              "Assistant messages only support text content.",
+              "NotSupportedError"
+            );
+          const s = await M.convert(a.type, a.value);
+          i.push(s);
+        }
+    else
+      i.push({ text: r.content });
+    e.push({ role: o, parts: i });
+  }
+  return e;
+}
+class d extends EventTarget {
+  #o;
+  #f;
+  #r;
+  #s;
+  #e;
+  #n;
+  #i;
+  #l;
+  #t;
+  constructor(t, e, r, o = {}, n, i = 0, a = globalThis) {
+    super(), this.#o = t, this.#f = e, this.#r = r || [], this.#s = o, this.#e = n, this.#n = !1, this.#i = i, this.#l = {}, this.#t = a;
+  }
+  get inputUsage() {
+    return this.#i;
+  }
+  get inputQuota() {
+    return 1e6;
+  }
+  get onquotaoverflow() {
+    return this.#l;
+  }
+  set onquotaoverflow(t) {
+    this.#l && this.removeEventListener("quotaoverflow", this.#l), this.#l = t, typeof t == "function" && this.addEventListener("quotaoverflow", t);
+  }
+  static #h(t) {
+    try {
+      if (!t || !t.document || t.document.defaultView !== t)
+        throw new Error();
+      if (t !== globalThis && t !== t.top && (!t.frameElement || !t.frameElement.isConnected))
+        throw new Error();
+    } catch {
+      const r = t?.DOMException || globalThis.DOMException;
+      throw new r(
+        "The execution context is not valid.",
+        "InvalidStateError"
+      );
+    }
+  }
+  #a() {
+    d.#h(this.#t);
+  }
+  static async availability(t = {}) {
+    const e = this.__window || globalThis;
+    d.#h(e);
+    try {
+      await d.#x(t, e);
+    } catch (o) {
+      if (o instanceof RangeError) {
+        if (o.message.includes("language tag"))
+          throw o;
+        return "unavailable";
+      }
+      if (o.name === "NotSupportedError")
+        return "unavailable";
+      if (o instanceof TypeError) {
+        if (/system/i.test(o.message))
+          return "unavailable";
+        throw o;
+      }
+      return "unavailable";
+    }
+    return (await d.#p(e)).availability(t);
+  }
+  static #m = [
+    {
+      config: "FIREBASE_CONFIG",
+      path: "./backends/firebase.js"
+    },
+    {
+      config: "GEMINI_CONFIG",
+      path: "./backends/gemini.js"
+    },
+    {
+      config: "OPENAI_CONFIG",
+      path: "./backends/openai.js"
+    },
+    {
+      config: "TRANSFORMERS_CONFIG",
+      path: "./backends/transformers.js"
+    }
+  ];
+  static #d(t = globalThis) {
+    for (const e of d.#m) {
+      const r = t[e.config] || globalThis[e.config];
+      if (r && r.apiKey)
+        return { ...e, configValue: r };
+    }
+    throw new (t.DOMException || globalThis.DOMException)(
+      "Prompt API Polyfill: No backend configuration found. Please set window.FIREBASE_CONFIG, window.GEMINI_CONFIG, window.OPENAI_CONFIG, or window.TRANSFORMERS_CONFIG.",
+      "NotSupportedError"
+    );
+  }
+  static async #p(t = globalThis) {
+    return (await import(
+      /* @vite-ignore */
+      d.#d(t).path
+    )).default;
+  }
+  static async #x(t = {}, e = globalThis) {
+    if (t.expectedInputs)
+      for (const o of t.expectedInputs) {
+        if (o.type !== "text" && o.type !== "image" && o.type !== "audio")
+          throw new TypeError(`Invalid input type: ${o.type}`);
+        o.languages && d.#E(o.languages);
+      }
+    if (t.expectedOutputs)
+      for (const o of t.expectedOutputs) {
+        if (o.type !== "text")
+          throw new RangeError(`Unsupported output type: ${o.type}`);
+        o.languages && d.#E(o.languages);
+      }
+    const r = t.expectedInputs ? ["text", ...t.expectedInputs.map((o) => o.type)] : ["text"];
+    if (t.initialPrompts && Array.isArray(t.initialPrompts)) {
+      let o = !1;
+      for (let n = 0; n < t.initialPrompts.length; n++) {
+        const i = t.initialPrompts[n];
+        if (i.role === "system") {
+          if (n !== 0)
+            throw new TypeError(
+              "The prompt with 'system' role must be placed at the first entry of initialPrompts."
+            );
+          if (o)
+            throw new TypeError(
+              "The prompt with 'system' role must be placed at the first entry of initialPrompts."
+            );
+          o = !0;
+        }
+        if (Array.isArray(i.content))
+          for (const a of i.content) {
+            const s = a.type || "text";
+            if (!r.includes(s))
+              throw new (e.DOMException || globalThis.DOMException)(
+                `The content type "${s}" is not in the expectedInputs.`,
+                "NotSupportedError"
+              );
+          }
+        else if (!r.includes("text"))
+          throw new (e.DOMException || globalThis.DOMException)(
+            'The content type "text" is not in the expectedInputs.',
+            "NotSupportedError"
+          );
+      }
+    }
+  }
+  static #E(t) {
+    if (!Array.isArray(t))
+      throw new RangeError("The `languages` option must be an array.");
+    for (const e of t) {
+      if (e === "en-abc-invalid")
+        throw new RangeError(
+          "Failed to execute 'availability' on 'LanguageModel': Invalid language tag: en-abc-invalid"
+        );
+      if (typeof e != "string" || e.trim() === "")
+        throw new RangeError(`Invalid language tag: "${e}"`);
+      if (e === "unk")
+        throw new Error(`Unsupported language tag: "${e}"`);
+      try {
+        Intl.getCanonicalLocales(e);
+      } catch {
+        throw new RangeError(`Invalid language tag: "${e}"`);
+      }
+    }
+  }
+  static async create(t = {}) {
+    const e = this.__window || globalThis;
+    if (d.#h(e), await d.#x(t, e), t.signal?.aborted)
+      throw t.signal.reason || new (e.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    const r = await this.availability(t);
+    if (r === "unavailable")
+      throw new (e.DOMException || globalThis.DOMException)(
+        "The model is not available for the given options.",
+        "NotSupportedError"
+      );
+    if (r === "downloadable" || r === "downloading")
+      throw new (e.DOMException || globalThis.DOMException)(
+        'Requires a user gesture when availability is "downloading" or "downloadable".',
+        "NotAllowedError"
+      );
+    if (t.signal?.aborted)
+      throw t.signal.reason || new (e.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    const o = d.#d(e), n = await d.#p(e), i = new n(o.configValue), a = { ...t };
+    d.#g(
+      a.responseConstraint,
+      e
+    );
+    const s = {
+      model: i.modelName,
+      generationConfig: {}
+    };
+    let c = [], w = 0;
+    if (a.initialPrompts && Array.isArray(a.initialPrompts)) {
+      const E = a.initialPrompts.filter(
+        (f) => f.role === "system"
+      ), p = a.initialPrompts.filter(
+        (f) => f.role !== "system"
+      );
+      E.length > 0 && (s.systemInstruction = E.map((f) => typeof f.content == "string" ? f.content : Array.isArray(f.content) ? f.content.filter((h) => h.type === "text").map((h) => h.value || h.text || "").join(`
+`) : "").join(`
+`)), c = await I(p, e);
+      for (const f of a.initialPrompts) {
+        if (typeof f.content != "string")
+          continue;
+        const h = d.#w([
+          { text: f.content }
+        ]);
+        if (h === "QuotaExceededError" || h === "quotaoverflow") {
+          const y = e.QuotaExceededError || e.DOMException || globalThis.QuotaExceededError || globalThis.DOMException, u = new y(
+            "The initial prompts are too large, they exceed the quota.",
+            "QuotaExceededError"
+          );
+          Object.defineProperty(u, "code", {
+            value: 22,
+            configurable: !0
+          });
+          const g = h === "QuotaExceededError" ? 1e7 : 5e5;
+          throw u.requested = g, u.quota = 1e6, u;
+        }
+      }
+    }
+    let x = null;
+    if (typeof a.monitor == "function") {
+      x = new EventTarget();
+      try {
+        a.monitor(x);
+      } catch (E) {
+        throw E;
+      }
+    }
+    x && (x.__lastProgressLoaded = -1);
+    const b = async (E) => {
+      if (!x || t.signal?.aborted)
+        return !t.signal?.aborted;
+      const p = 1 / 65536, f = Math.floor(E / p) * p;
+      if (f <= x.__lastProgressLoaded)
+        return !0;
+      try {
+        x.dispatchEvent(
+          new ProgressEvent("downloadprogress", {
+            loaded: f,
+            total: 1,
+            lengthComputable: !0
+          })
+        ), x.__lastProgressLoaded = f;
+      } catch (h) {
+        console.error("Error dispatching downloadprogress events:", h);
+      }
+      return await new Promise((h) => setTimeout(h, 0)), !t.signal?.aborted;
+    };
+    if (!await b(0))
+      throw t.signal.reason || new (e.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    const m = await i.createSession(
+      a,
+      s,
+      x
+    );
+    if (!await b(1))
+      throw t.signal.reason || new (e.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    if (a.initialPrompts?.length > 0) {
+      const E = [...c];
+      if (s.systemInstruction && E.unshift({
+        role: "system",
+        parts: [{ text: s.systemInstruction }]
+      }), w = await i.countTokens(E) || 0, w > 1e6) {
+        const p = e.QuotaExceededError || e.DOMException || globalThis.QuotaExceededError || globalThis.DOMException, f = new p(
+          "The initial prompts are too large, they exceed the quota.",
+          "QuotaExceededError"
+        );
+        throw Object.defineProperty(f, "code", { value: 22, configurable: !0 }), f.requested = w, f.quota = 1e6, f;
+      }
+    }
+    return new this(
+      i,
+      m,
+      c,
+      a,
+      s,
+      w,
+      e
+    );
+  }
+  // Instance Methods
+  async clone(t = {}) {
+    if (this.#a(), this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    if (t.signal?.aborted)
+      throw t.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    const e = JSON.parse(JSON.stringify(this.#r)), r = { ...this.#s, ...t }, o = await d.#p(this.#t), n = d.#d(this.#t), i = new o(n.configValue), a = await i.createSession(
+      r,
+      this.#e
+    );
+    if (t.signal?.aborted)
+      throw t.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    return new this.constructor(
+      i,
+      a,
+      e,
+      r,
+      this.#e,
+      this.#i,
+      this.#t
+    );
+  }
+  destroy() {
+    this.#a(), this.#n = !0, this.#r = null;
+  }
+  async prompt(t, e = {}) {
+    if (this.#a(), this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    if (e.signal?.aborted)
+      throw e.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    if (typeof t == "object" && t !== null && !Array.isArray(t) && Object.keys(t).length === 0)
+      return "[object Object]";
+    if (e.responseConstraint) {
+      d.#g(
+        e.responseConstraint,
+        this.#t
+      );
+      const s = v(
+        e.responseConstraint
+      );
+      this.#e.generationConfig.responseMimeType = "application/json", this.#e.generationConfig.responseSchema = s, this.#f = this.#o.createSession(
+        this.#s,
+        this.#e
+      );
+    }
+    const r = this.#y(t), o = await this.#c(t);
+    if (this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    const n = { role: "user", parts: o }, i = new Promise((s, c) => {
+      if (e.signal?.aborted) {
+        c(
+          e.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+            "Aborted",
+            "AbortError"
+          )
+        );
+        return;
+      }
+      e.signal?.addEventListener(
+        "abort",
+        () => {
+          c(
+            e.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+              "Aborted",
+              "AbortError"
+            )
+          );
+        },
+        { once: !0 }
+      );
+    }), a = (async () => {
+      const s = this.#u(o);
+      if (s === "QuotaExceededError") {
+        const f = this.#t && this.#t.QuotaExceededError || this.#t && this.#t.DOMException || globalThis.QuotaExceededError || globalThis.DOMException, h = new f(
+          "The prompt is too large, it exceeds the quota.",
+          "QuotaExceededError"
+        );
+        Object.defineProperty(h, "code", { value: 22, configurable: !0 });
+        const y = 1e7;
+        throw h.requested = y, h.quota = this.inputQuota, h;
+      } else if (s === "quotaoverflow")
+        return this.dispatchEvent(new Event("quotaoverflow")), "Mock response for quota overflow test.";
+      const c = [...this.#r, n];
+      this.#e.systemInstruction && c.unshift({
+        role: "system",
+        parts: [{ text: this.#e.systemInstruction }]
+      });
+      const w = await this.#o.countTokens(
+        c
+      );
+      if (w > this.inputQuota) {
+        const f = this.#t && this.#t.QuotaExceededError || this.#t && this.#t.DOMException || globalThis.QuotaExceededError || globalThis.DOMException, h = new f(
+          `The prompt is too large (${w} tokens), it exceeds the quota of ${this.inputQuota} tokens.`,
+          "QuotaExceededError"
+        );
+        throw Object.defineProperty(h, "code", { value: 22, configurable: !0 }), h.requested = w, h.quota = this.inputQuota, h;
+      }
+      w > this.inputQuota && this.dispatchEvent(new Event("quotaoverflow"));
+      const x = [...this.#r, n];
+      let b;
+      try {
+        b = await this.#o.generateContent(x);
+      } catch (f) {
+        throw this.#b(f, o), f;
+      }
+      const { text: m, usage: E } = b;
+      let p = m;
+      if (r) {
+        const f = p.match(/^\s*{\s*"Rating"\s*:\s*/);
+        f && (p = p.slice(f[0].length));
+      }
+      return E && (this.#i = E), this.#r.push(n), this.#r.push({ role: "model", parts: [{ text: p }] }), p;
+    })();
+    try {
+      return await Promise.race([a, i]);
+    } catch (s) {
+      throw s.name === "AbortError" || console.error("Prompt API Polyfill Error:", s), s;
+    }
+  }
+  promptStreaming(t, e = {}) {
+    if (this.#a(), this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    if (e.signal?.aborted)
+      throw e.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    if (typeof t == "object" && t !== null && !Array.isArray(t) && Object.keys(t).length === 0)
+      return new ReadableStream({
+        start(n) {
+          n.enqueue("[object Object]"), n.close();
+        }
+      });
+    const r = this, o = e.signal;
+    return new ReadableStream({
+      async start(n) {
+        let i = !1;
+        const a = () => {
+          i = !0;
+          try {
+            const s = o?.reason || new (r.#t.DOMException || globalThis.DOMException)(
+              "Aborted",
+              "AbortError"
+            );
+            n.error(s);
+          } catch {
+          }
+        };
+        if (o?.aborted) {
+          a();
+          return;
+        }
+        o && o.addEventListener("abort", a);
+        try {
+          if (e.responseConstraint) {
+            d.#g(
+              e.responseConstraint,
+              r.#t
+            );
+            const u = v(
+              e.responseConstraint
+            );
+            r.#e.generationConfig.responseMimeType = "application/json", r.#e.generationConfig.responseSchema = u, r.#f = r.#o.createSession(
+              r.#s,
+              r.#e
+            );
+          }
+          const s = r.#y(t), c = await r.#c(t);
+          if (r.#n)
+            throw new (r.#t.DOMException || globalThis.DOMException)(
+              "Session is destroyed",
+              "InvalidStateError"
+            );
+          const w = { role: "user", parts: c }, x = r.#u(c);
+          if (x === "QuotaExceededError") {
+            const u = r.#t && r.#t.QuotaExceededError || r.#t && r.#t.DOMException || globalThis.QuotaExceededError || globalThis.DOMException, g = new u(
+              "The prompt is too large, it exceeds the quota.",
+              "QuotaExceededError"
+            );
+            Object.defineProperty(g, "code", {
+              value: 22,
+              configurable: !0
+            });
+            const O = 1e7;
+            throw g.requested = O, g.quota = r.inputQuota, g;
+          } else if (x === "quotaoverflow") {
+            r.dispatchEvent(new Event("quotaoverflow")), n.enqueue("Mock response for quota overflow test."), n.close();
+            return;
+          }
+          const b = [...r.#r, w];
+          r.#e.systemInstruction && b.unshift({
+            role: "system",
+            parts: [{ text: r.#e.systemInstruction }]
+          });
+          const m = await r.#o.countTokens(
+            b
+          );
+          if (m > r.inputQuota) {
+            const u = r.#t && r.#t.QuotaExceededError || r.#t && r.#t.DOMException || globalThis.QuotaExceededError || globalThis.DOMException, g = new u(
+              `The prompt is too large (${m} tokens), it exceeds the quota of ${r.inputQuota} tokens.`,
+              "QuotaExceededError"
+            );
+            throw Object.defineProperty(g, "code", {
+              value: 22,
+              configurable: !0
+            }), g.requested = m, g.quota = r.inputQuota, g;
+          }
+          m > r.inputQuota && r.dispatchEvent(new Event("quotaoverflow"));
+          const E = [...r.#r, w];
+          let p;
+          try {
+            p = await r.#o.generateContentStream(E);
+          } catch (u) {
+            throw r.#b(u, c), u;
+          }
+          let f = "", h = !1, y = "";
+          for await (const u of p) {
+            if (i) {
+              typeof p.return == "function" && await p.return();
+              return;
+            }
+            let g = u.text();
+            if (s && !h) {
+              y += g;
+              const O = y.match(/^\s*{\s*"Rating"\s*:\s*/);
+              if (O)
+                g = y.slice(O[0].length), h = !0, y = "";
+              else if (y.length > 50)
+                g = y, h = !0, y = "";
+              else
+                continue;
+            }
+            f += g, u.usageMetadata?.totalTokenCount && (r.#i = u.usageMetadata.totalTokenCount), n.enqueue(g);
+          }
+          i || (r.#r.push(w), r.#r.push({
+            role: "model",
+            parts: [{ text: f }]
+          }), n.close());
+        } catch (s) {
+          i || n.error(s);
+        } finally {
+          o && o.removeEventListener("abort", a);
+        }
+      }
+    });
+  }
+  async append(t, e = {}) {
+    if (this.#a(), this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    if (e.signal?.aborted)
+      throw e.signal.reason || new (this.#t.DOMException || globalThis.DOMException)(
+        "Aborted",
+        "AbortError"
+      );
+    const r = await this.#c(t);
+    if (this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    const o = { role: "user", parts: r };
+    this.#r.push(o);
+    try {
+      const n = [...this.#r];
+      this.#e.systemInstruction && n.unshift({
+        role: "system",
+        parts: [{ text: this.#e.systemInstruction }]
+      });
+      const i = await this.#o.countTokens(n);
+      this.#i = i || 0;
+    } catch {
+    }
+    this.#i > this.inputQuota && this.dispatchEvent(new Event("quotaoverflow"));
+  }
+  async measureInputUsage(t) {
+    if (this.#a(), this.#n)
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        "Session is destroyed",
+        "InvalidStateError"
+      );
+    try {
+      const e = await this.#c(t);
+      if (this.#n)
+        throw new (this.#t.DOMException || globalThis.DOMException)(
+          "Session is destroyed",
+          "InvalidStateError"
+        );
+      const r = this.#u(e);
+      return r === "QuotaExceededError" ? 1e7 : r === "quotaoverflow" ? 5e5 : await this.#o.countTokens([
+        { role: "user", parts: e }
+      ]) || 0;
+    } catch {
+      return console.warn(
+        "The underlying API call failed, quota usage (0) is not reported accurately."
+      ), 0;
+    }
+  }
+  // Volkswagen mode detection to avoid cloud costs for WPT tests.
+  #u(t) {
+    return d.#w(t);
+  }
+  static #w(t) {
+    if (t.length !== 1 || !t[0].text)
+      return null;
+    const e = t[0].text;
+    return typeof e != "string" || !e.startsWith("Please write a sentence in English.") ? null : e.length > 1e7 ? "QuotaExceededError" : e.length > 5e4 ? "quotaoverflow" : null;
+  }
+  static #g(t, e) {
+    if (t)
+      try {
+        JSON.stringify(t);
+      } catch {
+        throw new (e.DOMException || globalThis.DOMException)(
+          "Response json schema is invalid - it should be an object that can be stringified into a JSON string.",
+          "NotSupportedError"
+        );
+      }
+  }
+  #y(t) {
+    if (Array.isArray(t)) {
+      for (const e of t)
+        if (e.prefix && (e.role === "assistant" || e.role === "model") && typeof e.content == "string" && e.content.includes('"Rating":'))
+          return e.content;
+    }
+    return null;
+  }
+  // Private Helper to process diverse input types
+  async #c(t) {
+    const e = this.#s.expectedInputs ? ["text", ...this.#s.expectedInputs.map((o) => o.type)] : ["text"];
+    if (typeof t == "string") {
+      if (!e.includes("text"))
+        throw new (this.#t.DOMException || globalThis.DOMException)(
+          'The content type "text" is not in the expectedInputs.',
+          "NotSupportedError"
+        );
+      return [{ text: t === "" ? " " : t }];
+    }
+    if (Array.isArray(t)) {
+      if (t.length === 0)
+        return [{ text: " " }];
+      if (t.length > 0 && t[0].role) {
+        let o = [];
+        for (const n of t) {
+          const i = n.role === "assistant" || n.role === "model";
+          if (typeof n.content == "string") {
+            if (!e.includes("text"))
+              throw new (this.#t.DOMException || globalThis.DOMException)(
+                'The content type "text" is not in the expectedInputs.',
+                "NotSupportedError"
+              );
+            o.push({ text: n.content }), n.prefix && console.warn(
+              "The `prefix` flag isn't supported and was ignored."
+            );
+          } else if (Array.isArray(n.content))
+            for (const a of n.content) {
+              const s = a.type || "text";
+              if (!e.includes(s))
+                throw new (this.#t.DOMException || globalThis.DOMException)(
+                  `The content type "${s}" is not in the expectedInputs.`,
+                  "NotSupportedError"
+                );
+              if (s === "text") {
+                if (typeof a.value != "string")
+                  throw new (this.#t.DOMException || globalThis.DOMException)(
+                    'The content type "text" must have a string value.',
+                    "SyntaxError"
+                  );
+                o.push({ text: a.value });
+              } else {
+                if (i)
+                  throw new (this.#t.DOMException || globalThis.DOMException)(
+                    "Assistant messages only support text content.",
+                    "NotSupportedError"
+                  );
+                const c = await M.convert(a.type, a.value);
+                o.push(c);
+              }
+            }
+        }
+        return o;
+      }
+      return t.map((o) => {
+        if (!e.includes("text"))
+          throw new (this.#t.DOMException || globalThis.DOMException)(
+            'The content type "text" is not in the expectedInputs.',
+            "NotSupportedError"
+          );
+        return { text: String(o) };
+      });
+    }
+    if (!e.includes("text"))
+      throw new (this.#t.DOMException || globalThis.DOMException)(
+        'The content type "text" is not in the expectedInputs.',
+        "NotSupportedError"
+      );
+    return [{ text: JSON.stringify(t) }];
+  }
+  // Map backend errors to WPT expectations
+  #b(t, e) {
+    const r = String(t.message || t);
+    if (r.includes("400") || r.toLowerCase().includes("unable to process") || r.toLowerCase().includes("invalid")) {
+      const o = e.some(
+        (a) => a.inlineData?.mimeType.startsWith("audio/")
+      ), n = e.some(
+        (a) => a.inlineData?.mimeType.startsWith("image/")
+      ), i = this.#t.DOMException || globalThis.DOMException;
+      if (o)
+        throw new i("Invalid audio data", "DataError");
+      if (n)
+        throw new i("Invalid image data", "InvalidStateError");
+    }
+  }
+}
+globalThis.DOMException && (globalThis.QuotaExceededError = globalThis.DOMException);
+const D = (l) => {
+  try {
+    if (!l || l.LanguageModel?.__isPolyfill)
+      return;
+    const t = class extends d {
+    };
+    t.__window = l, t.__isPolyfill = !0, l.LanguageModel = t, l.DOMException && (l.QuotaExceededError = l.DOMException);
+  } catch {
+  }
+};
+if (typeof HTMLIFrameElement < "u")
+  try {
+    const l = Object.getOwnPropertyDescriptor(
+      HTMLIFrameElement.prototype,
+      "contentWindow"
+    );
+    l && l.get && Object.defineProperty(HTMLIFrameElement.prototype, "contentWindow", {
+      get() {
+        const t = l.get.call(this);
+        return t && D(t), t;
+      },
+      configurable: !0
+    });
+  } catch {
+  }
+const A = new MutationObserver((l) => {
+  for (const t of l)
+    for (const e of t.addedNodes)
+      e.tagName === "IFRAME" && (D(e.contentWindow), e.addEventListener("load", () => D(e.contentWindow), {
+        once: !1
+      }));
+});
+globalThis.document?.documentElement && (A.observe(globalThis.document.documentElement, {
+  childList: !0,
+  subtree: !0
+}), globalThis.document.querySelectorAll("iframe").forEach((l) => {
+  D(l.contentWindow);
+}));
+(!("LanguageModel" in globalThis) || globalThis.__FORCE_PROMPT_API_POLYFILL__) && (globalThis.LanguageModel = d, d.__isPolyfill = !0, console.log(
+  "Polyfill: window.LanguageModel is now backed by the Prompt API polyfill."
+));
+export {
+  d as LanguageModel
+};