blitz-pdf 0.1.4 → 0.1.6

package/src/api.ts

@@ -1,44 +1,55 @@
-import loadWasm, { render_pdf, engine_version, RenderJob } from "../wasm/blitz_pdf.js";
+import loadWasm, { engine_version } from "../wasm/blitz_pdf.js";
 import { createAssetLoader } from "./assets.js";
 import { normalizeOptions } from "./options.js";
+import { render, validateHtml } from "./render.js";
+import { compileWasm } from "./wasm.js";
+import { renderInWorker, type SpawnWorker } from "./worker-host.js";
 import type { InitOptions, PdfOptions, WasmSource } from "./types.js";
 
-export function createApi(defaultSource: () => Promise<WasmSource> | WasmSource,
-  prepare: (source: WasmSource) => Promise<WasmSource> = async source => source) {
+export interface ApiConfig {
+  defaultSource: () => Promise<WasmSource> | WasmSource;
+  prepare?: (source: WasmSource) => Promise<WasmSource>;
+  spawnWorker: SpawnWorker;
+}
+
+export function createApi({ defaultSource, prepare = async source => source, spawnWorker }: ApiConfig) {
+  let compiled: Promise<WebAssembly.Module> | undefined;
   let ready: Promise<void> | undefined;
 
+  function compile(source?: WasmSource): Promise<WebAssembly.Module> {
+    if (compiled) return compiled;
+    compiled = (async () => compileWasm(await prepare(source ?? await defaultSource())))()
+      .catch((error: unknown) => { compiled = undefined; throw error; });
+    return compiled;
+  }
+
   /** Initialize once. Concurrent callers share initialization; failed loads can be retried. */
   function init(options: InitOptions = {}): Promise<void> {
     if (ready) return ready;
     ready = (async () => {
-      const source = await prepare(options.wasm ?? await defaultSource());
-      await loadWasm({ module_or_path: source });
+      await loadWasm({ module_or_path: await compile(options.wasm) });
     })().catch((error: unknown) => { ready = undefined; throw error; });
     return ready;
   }
 
+  /** The compiled WASM module, compiled once and shared with every worker. It can be posted to your own workers. */
+  function getWasmModule(): Promise<WebAssembly.Module> { return compile(); }
+
   /** Render HTML/CSS to a vector PDF/A-3u with embedded fonts and selectable text. */
   async function renderPdf(html: string, options: PdfOptions = {}): Promise<Uint8Array> {
-    if (typeof html !== "string") throw new TypeError("html must be a string");
-    if (new TextEncoder().encode(html).byteLength > 16 * 1024 * 1024) throw new RangeError("HTML exceeds the 16 MiB limit");
+    validateHtml(html);
     const { assetResolver, ...normalized } = normalizeOptions(options);
     await init();
-    if (!assetResolver) return render_pdf(html, normalized);
-    const load = createAssetLoader(assetResolver);
-    const job = new RenderJob(html, normalized);
-    try {
-      for (;;) {
-        const urls = job.pending_assets();
-        if (urls.length === 0) return job.finish();
-        const data = await load(urls);
-        for (let i = 0; i < urls.length; i++) job.provide_asset(urls[i]!, data[i]!);
-      }
-    } finally {
-      // In-flight JS loaders never access this job, including after a sibling rejects.
-      job.free();
-    }
+    return render(html, normalized, assetResolver && createAssetLoader(assetResolver));
+  }
+
+  /** Like `renderPdf`, but layout and serialization run in a new worker. An `assets` function still runs on the calling thread. */
+  async function renderPdfInWorker(html: string, options: PdfOptions = {}): Promise<Uint8Array> {
+    validateHtml(html);
+    const { assetResolver, ...normalized } = normalizeOptions(options);
+    return renderInWorker(spawnWorker, await compile(), html, normalized, assetResolver);
   }
 
   async function getEngineVersion(): Promise<string> { await init(); return engine_version(); }
-  return { init, renderPdf, getEngineVersion };
+  return { init, renderPdf, renderPdfInWorker, getWasmModule, getEngineVersion };
 }

package/src/browser.ts

@@ -1,6 +1,16 @@
 import { createApi } from "./api.js";
 
 export type { AssetData, AssetMap, AssetResolver, AttachmentRelationship, BinaryData, InitOptions, Length, PageFormat, PageNumberOptions, PdfAttachment, PdfDate, PdfMetadata, PdfOptions, PdfXmpProperty, PdfXmpSchema, WasmSource } from "./types.js";
-export const { init, renderPdf, getEngineVersion } = createApi(
-  () => new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url),
-);
+export const { init, renderPdf, renderPdfInWorker, getWasmModule, getEngineVersion } = createApi({
+  defaultSource: () => new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url),
+  spawnWorker: events => {
+    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+    worker.onmessage = event => events.message(event.data);
+    worker.onerror = event => {
+      event.preventDefault();
+      events.error(new Error(`Render worker failed: ${event.message || "unknown error"}`));
+    };
+    worker.onmessageerror = () => events.error(new Error("Render worker sent a message that could not be deserialized"));
+    return { post: (message, transfer) => worker.postMessage(message, transfer), terminate: () => worker.terminate() };
+  },
+});

package/src/node-worker.ts

@@ -0,0 +1,9 @@
+import { parentPort } from "node:worker_threads";
+import { serve } from "./worker-runtime.js";
+
+const port = parentPort;
+if (!port) throw new Error("blitz-pdf node-worker must run in a worker thread");
+serve({
+  post: (message, transfer) => port.postMessage(message, transfer),
+  onMessage: handler => { port.on("message", handler); },
+});

package/src/node.ts

@@ -1,12 +1,21 @@
 import { readFile } from "node:fs/promises";
+import { Worker } from "node:worker_threads";
 import { createApi } from "./api.js";
 
 export type { AssetData, AssetMap, AssetResolver, AttachmentRelationship, BinaryData, InitOptions, Length, PageFormat, PageNumberOptions, PdfAttachment, PdfDate, PdfMetadata, PdfOptions, PdfXmpProperty, PdfXmpSchema, WasmSource } from "./types.js";
-export const { init, renderPdf, getEngineVersion } = createApi(
-  () => readFile(new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url)),
-  async source => {
+export const { init, renderPdf, renderPdfInWorker, getWasmModule, getEngineVersion } = createApi({
+  defaultSource: () => readFile(new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url)),
+  prepare: async source => {
     if (source instanceof URL && source.protocol === "file:") return readFile(source);
     if (typeof source === "string" && source.startsWith("file:")) return readFile(new URL(source));
     return source;
   },
-);
+  spawnWorker: events => {
+    const worker = new Worker(new URL("./node-worker.js", import.meta.url));
+    worker.on("message", events.message);
+    worker.on("error", events.error);
+    worker.on("messageerror", events.error);
+    worker.on("exit", code => events.error(new Error(`Render worker exited with code ${code}`)));
+    return { post: (message, transfer) => worker.postMessage(message, transfer), terminate: () => void worker.terminate() };
+  },
+});

package/src/render.ts

@@ -0,0 +1,28 @@
+import { render_pdf, RenderJob } from "../wasm/blitz_pdf.js";
+import type { normalizeOptions } from "./options.js";
+
+/** Normalized options without the resolver function, so they can be posted to a worker. */
+export type RenderOptions = Omit<ReturnType<typeof normalizeOptions>, "assetResolver">;
+export type LoadAssets = (urls: string[]) => Promise<Uint8Array[]>;
+
+export function validateHtml(html: unknown): asserts html is string {
+  if (typeof html !== "string") throw new TypeError("html must be a string");
+  if (new TextEncoder().encode(html).byteLength > 16 * 1024 * 1024) throw new RangeError("HTML exceeds the 16 MiB limit");
+}
+
+/** Requires an initialized WASM instance in the current thread. */
+export async function render(html: string, options: RenderOptions, load?: LoadAssets): Promise<Uint8Array> {
+  if (!load) return render_pdf(html, options);
+  const job = new RenderJob(html, options);
+  try {
+    for (;;) {
+      const urls = job.pending_assets();
+      if (urls.length === 0) return job.finish();
+      const data = await load(urls);
+      for (let i = 0; i < urls.length; i++) job.provide_asset(urls[i]!, data[i]!);
+    }
+  } finally {
+    // In-flight JS loaders never access this job, including after a sibling rejects.
+    job.free();
+  }
+}

package/src/wasm.ts

@@ -0,0 +1,17 @@
+import type { WasmSource } from "./types.js";
+
+export async function compileWasm(source: WasmSource): Promise<WebAssembly.Module> {
+  if (source instanceof WebAssembly.Module) return source;
+  if (typeof source === "string" || source instanceof URL || (typeof Request === "function" && source instanceof Request)) {
+    source = await fetch(source);
+  }
+  if (typeof Response === "function" && source instanceof Response) {
+    if (!source.ok) throw new Error(`Failed to fetch WASM: ${source.status} ${source.statusText} fetching '${source.url}'`);
+    // Streaming compilation rejects other MIME types, so fall back to buffering instead.
+    if (typeof WebAssembly.compileStreaming === "function" && source.headers.get("Content-Type") === "application/wasm") {
+      return WebAssembly.compileStreaming(source);
+    }
+    return WebAssembly.compile(await source.arrayBuffer());
+  }
+  return WebAssembly.compile(source as BufferSource);
+}

package/src/worker-host.ts

@@ -0,0 +1,45 @@
+import { createAssetLoader } from "./assets.js";
+import type { RenderOptions } from "./render.js";
+import type { AssetResolver } from "./types.js";
+import type { HostMessage, WorkerMessage } from "./worker-protocol.js";
+
+export interface WorkerEvents {
+  message(message: WorkerMessage): void;
+  /** Crashes, unreadable messages, or an exit before the render settled. */
+  error(error: unknown): void;
+}
+
+export interface WorkerHandle {
+  post(message: HostMessage, transfer: ArrayBuffer[]): void;
+  terminate(): void;
+}
+
+export type SpawnWorker = (events: WorkerEvents) => WorkerHandle;
+
+/** Renders in a fresh worker that instantiates the precompiled module, then terminates it. */
+export function renderInWorker(spawn: SpawnWorker, module: WebAssembly.Module, html: string,
+  options: RenderOptions, resolver: AssetResolver | undefined): Promise<Uint8Array> {
+  return new Promise<Uint8Array>((resolve, reject) => {
+    const load = resolver && createAssetLoader(resolver);
+    let settled = false;
+    const settle = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      worker.terminate();
+      callback();
+    };
+    const worker: WorkerHandle = spawn({
+      message(message) {
+        if (message.type === "done") settle(() => resolve(message.pdf));
+        else if (message.type === "error") settle(() => reject(message.error));
+        else if (!load) settle(() => reject(new Error("Render worker requested assets without a resolver")));
+        else load(message.urls).then(
+          data => { if (!settled) worker.post({ type: "assets", data }, data.map(bytes => bytes.buffer as ArrayBuffer)); },
+          (error: unknown) => settle(() => reject(error)),
+        );
+      },
+      error(error) { settle(() => reject(error)); },
+    });
+    worker.post({ type: "render", module, html, options, external: load !== undefined }, []);
+  });
+}

package/src/worker-protocol.ts

@@ -0,0 +1,10 @@
+import type { RenderOptions } from "./render.js";
+
+export type HostMessage =
+  | { type: "render"; module: WebAssembly.Module; html: string; options: RenderOptions; external: boolean }
+  | { type: "assets"; data: Uint8Array[] };
+
+export type WorkerMessage =
+  | { type: "assets"; urls: string[] }
+  | { type: "done"; pdf: Uint8Array }
+  | { type: "error"; error: unknown };

package/src/worker-runtime.ts

@@ -0,0 +1,35 @@
+import { initSync } from "../wasm/blitz_pdf.js";
+import { render } from "./render.js";
+import type { HostMessage, WorkerMessage } from "./worker-protocol.js";
+
+export interface WorkerEndpoint {
+  post(message: WorkerMessage, transfer: ArrayBuffer[]): void;
+  onMessage(handler: (message: HostMessage) => void): void;
+}
+
+/** Worker side of `renderPdfInWorker`: one render per worker; asset bytes come from the host. */
+export function serve(endpoint: WorkerEndpoint): void {
+  let receiveAssets: ((data: Uint8Array[]) => void) | undefined;
+  endpoint.onMessage(async message => {
+    if (message.type === "assets") {
+      const receive = receiveAssets;
+      receiveAssets = undefined;
+      receive?.(message.data);
+      return;
+    }
+    try {
+      initSync({ module: message.module });
+      const load = message.external
+        ? (urls: string[]) => new Promise<Uint8Array[]>(resolve => {
+          receiveAssets = resolve;
+          endpoint.post({ type: "assets", urls }, []);
+        })
+        : undefined;
+      const pdf = await render(message.html, message.options, load);
+      endpoint.post({ type: "done", pdf }, [pdf.buffer as ArrayBuffer]);
+    } catch (error) {
+      try { endpoint.post({ type: "error", error }, []); }
+      catch { endpoint.post({ type: "error", error: new Error(String(error)) }, []); }
+    }
+  });
+}

package/src/worker.ts

@@ -0,0 +1,12 @@
+import { serve } from "./worker-runtime.js";
+
+interface DedicatedWorkerScope {
+  postMessage(message: unknown, transfer: Transferable[]): void;
+  onmessage: ((event: MessageEvent) => void) | null;
+}
+
+const scope = globalThis as unknown as DedicatedWorkerScope;
+serve({
+  post: (message, transfer) => scope.postMessage(message, transfer),
+  onMessage: handler => { scope.onmessage = event => handler(event.data); },
+});

package/vendor/README.md

@@ -75,3 +75,27 @@ against rebuilt WASM. Layout tests check physical margins, fractional viewport
 widths, header/footer geometry, table line spacing, descendant alignment, empty
 paragraphs, explicit empty-box dimensions, exact page-boundary fits, constrained
 table columns, anonymous cells, and inheritance after CSS page-size changes.
+
+# Blitz Unicode paint notifications
+
+`blitz-paint/` contains `packages/blitz-paint` from Blitz revision
+`e72650a6e67941852fddf025295cfee30c39ea32`, with its MIT/Apache-2.0 licenses.
+Its standalone manifest expands the upstream workspace dependencies and pins
+sibling crates to the same revision.
+
+- `src/lib.rs`: add the opt-in `TextObserver` and `paint_scene_with_text` API.
+  The original `paint_scene` entry point keeps its existing behavior.
+- `src/render.rs`: notify the observer immediately before painting inline text,
+  input/textarea text, and outside list markers; forward it to subdocuments.
+  The notifications supply the exact Parley layout and source string in paint
+  order, including visibility and stacking order decisions.
+
+The PDF renderer associates the observed runs with individual scene commands
+and checks that their glyphs match. It retains this immutable association when
+replaying pages or repeated table fragments. It no longer uses glyph shapes as
+document-wide source-text identities: `fi` and `fi`, for example, legitimately
+share a shape while requiring different Unicode mappings.
+
+When upgrading Blitz, retain these notifications at all text-paint boundaries
+and run `tests/unicode.test.ts` (requires Poppler), the existing rendering,
+pagination, and template suites, and `npm run test:pdfa` on the rebuilt WASM.

package/vendor/blitz-paint/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "blitz-paint"
+description = "Paint a Blitz Document using anyrender"
+documentation = "https://docs.rs/blitz-paint"
+version = "0.3.0-beta.3"
+license = "MIT OR Apache-2.0"
+homepage = "https://github.com/dioxuslabs/blitz"
+repository = "https://github.com/dioxuslabs/blitz"
+categories = ["gui"]
+edition = "2024"
+rust-version = "1.91.0"
+
+[features]
+default = ["svg"]
+tracing = ["dep:tracing"]
+svg = ["dep:anyrender_svg", "dep:usvg", "blitz-dom/svg"]
+custom-widget = ["blitz-dom/custom-widget"]
+font-embolden = []
+apple-font-embolden = []
+# Paint overlay scrollbar thumbs on scroll containers, and enable their
+# drag/hover interaction in blitz-dom (off by default while the feature
+# matures).
+scrollbars = ["blitz-dom/scrollbars"]
+
+[dependencies]
+# Blitz dependencies
+anyrender = { version = "0.14.0" }
+anyrender_svg = { version = "0.15.0", optional = true }
+blitz-traits = { version = "=0.3.0-beta.3", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32" }
+blitz-dom = { version = "=0.3.0-beta.3", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32" }
+
+# Servo dependencies
+style = { version = "0.22.0", package = "stylo" }
+euclid = { version = "0.22" }
+
+# DioxusLabs dependencies
+taffy = { git = "https://github.com/DioxusLabs/taffy", rev = "6c2106e3df79493d304f954dc2cd4a4a382981d3", default-features = false, features = ["std", "flexbox", "flexbox_balance", "grid", "block_layout", "content_size", "calc", "detailed_layout_info"] }
+
+# Linebender + WGPU dependencies
+parley = { version = "0.12", default-features = false, features = ["std", "bytemuck"] }
+skrifa = { version = "0.44", default-features = false, features = ["std"] }
+color = { version = "0.3" }
+peniko = { version = "0.6.0" }
+kurbo = { version = "0.13.1" }
+usvg = { version = "0.48.1", optional = true }
+
+# Other dependencies
+bytemuck = { version = "1" }
+smallvec = { version = "1" }
+tracing = { version = "0.1.40", optional = true }

package/vendor/blitz-paint/LICENSE-APACHE

@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/vendor/blitz-paint/LICENSE-MIT

@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/vendor/blitz-paint/src/color.rs

@@ -0,0 +1,66 @@
+use color::{AlphaColor, DynamicColor, Srgb};
+use style::color::AbsoluteColor;
+
+pub type Color = AlphaColor<Srgb>;
+
+pub trait ToColorColor {
+    /// Converts a color into the `AlphaColor<Srgb>` type from the `color` crate
+    fn as_srgb_color(&self) -> Color;
+
+    /// Converts a color into the `DynamicColor` type from the `color` crate
+    fn as_dynamic_color(&self) -> DynamicColor;
+}
+impl ToColorColor for AbsoluteColor {
+    fn as_srgb_color(&self) -> Color {
+        Color::new(
+            *self
+                .to_color_space(style::color::ColorSpace::Srgb)
+                .raw_components(),
+        )
+    }
+
+    fn as_dynamic_color(&self) -> DynamicColor {
+        DynamicColor::from_alpha_color(self.as_srgb_color())
+    }
+}
+
+/// The WCAG contrast ratio (>= 1) between two colours, matching Chrome's
+/// `color_utils::GetContrastRatio`.
+pub(crate) fn contrast_ratio(a: Color, b: Color) -> f32 {
+    // `relative_luminance` is defined on `OpaqueColor`; discard the alpha (which
+    // it ignores anyway) with `split`.
+    let la = a.split().0.relative_luminance() + 0.05;
+    let lb = b.split().0.relative_luminance() + 0.05;
+    if la > lb { la / lb } else { lb / la }
+}
+
+/// Blend `color` towards black or white (whichever has contrast headroom)
+/// just far enough to reach `target` contrast with the original, so the
+/// result is visibly distinct for any input. Transparent colours pass
+/// through unchanged; alpha is preserved.
+#[cfg(feature = "scrollbars")]
+pub(crate) fn blend_for_contrast(color: Color, target: f32) -> Color {
+    let alpha = color.components[3];
+    if alpha == 0.0 {
+        return color;
+    }
+    let white = Color::new([1.0, 1.0, 1.0, alpha]);
+    let black = Color::new([0.0, 0.0, 0.0, alpha]);
+    let pole = if contrast_ratio(color, white) >= contrast_ratio(color, black) {
+        white
+    } else {
+        black
+    };
+    // Contrast grows monotonically towards the pole: bisect the blend
+    // fraction to land just past the target ratio.
+    let (mut lo, mut hi) = (0.0_f32, 1.0_f32);
+    for _ in 0..8 {
+        let mid = (lo + hi) / 2.0;
+        if contrast_ratio(color, color.lerp_rect(pole, mid)) < target {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+    color.lerp_rect(pole, hi)
+}