@pixerate/editor 0.268.1 → 0.269.0

package/dist/{chunk-3XDSNIGF.js → chunk-ININNHLM.js}

@@ -3,6 +3,7 @@ import {
 } from "./chunk-VE6UKYQ2.js";
 import {
   BRUSH_HOST_PROFILES,
+  BRUSH_ID,
   BRUSH_JSON_SCHEMA,
   BRUSH_KINDS,
   BRUSH_MEDIA,
@@ -12,6 +13,7 @@ import {
   MAX_BRUSH_SOURCE_INPUT_PIXELS,
   MAX_BRUSH_SOURCE_SIZE,
   PAINT_PROFILE,
+  brushSourceFromMask,
   brushSourceIdOf,
   brushSourceIds,
   brushSourceRef,
@@ -19,12 +21,19 @@ import {
   closest,
   degrade,
   isBrushSourceRef,
+  makeBrushSource,
   normalizeBrushSpec,
   resolveCategory,
   resolveEngine,
   summarizeBrushSource,
   withKeptIssues
 } from "./chunk-KZI3YWKW.js";
+import {
+  base64ToBytes
+} from "./chunk-OTTT5N3K.js";
+import {
+  inflateRaw
+} from "./chunk-QGHEDC7B.js";
 
 // src/brushes/patch.ts
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -58,6 +67,638 @@ function changedBrushPaths(a, b, path = "") {
   return JSON.stringify(a) === JSON.stringify(b) ? [] : [path];
 }
 
+// src/brushes/import/abr.ts
+var AbrError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbrError";
+  }
+};
+var MAX_TIP_PIXELS = 5e3 * 5e3;
+var MAX_TIPS = 1e3;
+var Reader = class {
+  constructor(bytes, end = bytes.length) {
+    this.bytes = bytes;
+    this.end = end;
+  }
+  bytes;
+  end;
+  pos = 0;
+  need(n) {
+    if (n < 0 || this.pos + n > this.end) throw new AbrError("The brush file ends early or a size in it is wrong.");
+  }
+  u8() {
+    this.need(1);
+    return this.bytes[this.pos++];
+  }
+  u16() {
+    this.need(2);
+    const v = this.bytes[this.pos] << 8 | this.bytes[this.pos + 1];
+    this.pos += 2;
+    return v;
+  }
+  i16() {
+    const v = this.u16();
+    return v & 32768 ? v - 65536 : v;
+  }
+  u32() {
+    this.need(4);
+    const b = this.bytes;
+    const v = (b[this.pos] << 24 | b[this.pos + 1] << 16 | b[this.pos + 2] << 8 | b[this.pos + 3]) >>> 0;
+    this.pos += 4;
+    return v;
+  }
+  i32() {
+    return this.u32() | 0;
+  }
+  take(n) {
+    this.need(n);
+    const out = this.bytes.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  skip(n) {
+    this.need(n);
+    this.pos += n;
+  }
+  ascii(n) {
+    return String.fromCharCode(...this.take(n));
+  }
+};
+function unpackRows(r, height, rowBytes) {
+  const lengths = [];
+  for (let y = 0; y < height; y++) lengths.push(r.u16());
+  const out = new Uint8Array(rowBytes * height);
+  for (let y = 0; y < height; y++) {
+    const row = new Reader(r.take(lengths[y]));
+    let x = 0;
+    while (row.pos < row.end && x < rowBytes) {
+      const n = row.u8();
+      if (n < 128) {
+        const run = Math.min(n + 1, rowBytes - x);
+        out.set(row.take(run), y * rowBytes + x);
+        if (n + 1 > run) row.skip(Math.min(n + 1 - run, row.end - row.pos));
+        x += run;
+      } else if (n > 128) {
+        const v = row.u8();
+        const run = Math.min(257 - n, rowBytes - x);
+        out.fill(v, y * rowBytes + x, y * rowBytes + x + run);
+        x += run;
+      }
+    }
+  }
+  return out;
+}
+function readImage(r, width, height, depth, compression) {
+  if (!(width > 0 && height > 0)) throw new AbrError(`A tip is ${width}\xD7${height} px.`);
+  if (width * height > MAX_TIP_PIXELS) throw new AbrError(`A tip is ${width}\xD7${height} px; tips over ${MAX_TIP_PIXELS} pixels are not read.`);
+  if (depth !== 8 && depth !== 16) throw new AbrError(`A tip has ${depth}-bit depth; 8 and 16 bits are read.`);
+  const bpp = depth / 8;
+  const rowBytes = width * bpp;
+  const data = compression === 0 ? r.take(rowBytes * height) : compression === 1 ? unpackRows(r, height, rowBytes) : null;
+  if (!data) throw new AbrError(`A tip uses compression ${compression}; raw and PackBits are read.`);
+  if (bpp === 1) return Uint8Array.from(data);
+  const out = new Uint8Array(width * height);
+  for (let i = 0; i < out.length; i++) out[i] = data[i * 2];
+  return out;
+}
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+function readV1(r, version, file) {
+  const count = r.u16();
+  for (let i = 0; i < count && file.tips.length < MAX_TIPS; i++) {
+    const type = r.u16();
+    const size = r.u32();
+    r.need(size);
+    const end = r.pos + size;
+    const b = new Reader(r.bytes, end);
+    b.pos = r.pos;
+    try {
+      if (type === 1) {
+        b.skip(4);
+        const spacing = b.u16();
+        const diameter = b.u16();
+        const roundness = b.u16();
+        const angle = b.i16();
+        const hardness = b.u16();
+        file.tips.push({ kind: "computed", diameter: clamp(diameter, 1, 2500), roundness: clamp(roundness / 100, 0.01, 1), angle: clamp(angle, -180, 180), hardness: clamp(hardness / 100, 0, 1), spacing: clamp(spacing / 100, 0.01, 10) });
+      } else if (type === 2) {
+        b.skip(4);
+        const spacing = b.u16();
+        let name;
+        if (version === 2) {
+          const n = b.u32();
+          if (n > 1024) throw new AbrError("A tip name is too long.");
+          const chars = [];
+          for (let k = 0; k < n; k++) chars.push(b.u16());
+          name = String.fromCharCode(...chars).replace(/\0+$/, "").trim() || void 0;
+        }
+        b.skip(1 + 8);
+        const top = b.i32();
+        const left = b.i32();
+        const bottom = b.i32();
+        const right = b.i32();
+        const depth = b.u16();
+        const compression = b.u8();
+        const width = right - left;
+        const height = bottom - top;
+        file.tips.push({ kind: "sampled", ...name ? { name } : {}, width, height, mask: readImage(b, width, height, depth, compression), ...spacing ? { spacing: clamp(spacing / 100, 0.01, 10) } : {} });
+      } else file.unsupported.push(`Brush ${i + 1} is of type ${type}, which is not read.`);
+    } catch (e) {
+      file.unsupported.push(`Brush ${i + 1} could not be read: ${e.message}`);
+    }
+    r.pos = end;
+  }
+}
+function readDescriptor(bytes) {
+  const out = /* @__PURE__ */ new Map();
+  const find = (pattern, from) => {
+    outer: for (let p = from; p <= bytes.length - pattern.length; p++) {
+      for (let k = 0; k < pattern.length; k++) if (bytes[p + k] !== pattern[k]) continue outer;
+      return p;
+    }
+    return -1;
+  };
+  const code = (s) => [...s].map((c) => c.charCodeAt(0));
+  const text = (p) => {
+    const r = new Reader(bytes);
+    r.pos = p;
+    try {
+      const n = r.u32();
+      if (n > 512) return null;
+      const chars = [];
+      for (let k = 0; k < n; k++) chars.push(r.u16());
+      return String.fromCharCode(...chars).replace(/\0+$/, "");
+    } catch {
+      return null;
+    }
+  };
+  const NAME = code("Nm  TEXT");
+  const SAMPLED = code("sampledDataTEXT");
+  const SPACING = code("SpcnUntF#Prc");
+  let lastName;
+  let lastNameAt = -1;
+  for (let p = find(SAMPLED, 0); p >= 0; p = find(SAMPLED, p + SAMPLED.length)) {
+    for (let q = find(NAME, lastNameAt + 1); q >= 0 && q < p; q = find(NAME, q + NAME.length)) {
+      lastName = text(q + NAME.length) ?? void 0;
+      lastNameAt = q;
+    }
+    const uuid = text(p + SAMPLED.length);
+    if (!uuid) continue;
+    const s = find(SPACING, p);
+    let spacing;
+    if (s >= 0 && s + SPACING.length + 8 <= bytes.length) {
+      const v = new DataView(bytes.buffer, bytes.byteOffset + s + SPACING.length, 8).getFloat64(0);
+      if (Number.isFinite(v) && v > 0) spacing = clamp(v / 100, 0.01, 10);
+    }
+    if (!out.has(uuid)) out.set(uuid, { ...lastName ? { name: lastName.trim() } : {}, ...spacing !== void 0 ? { spacing } : {} });
+  }
+  return out;
+}
+function readV6(r, subversion, file) {
+  const samples = [];
+  let presets = /* @__PURE__ */ new Map();
+  while (r.pos + 12 <= r.end) {
+    const sig = r.ascii(4);
+    if (sig !== "8BIM" && sig !== "8B64") break;
+    const key = r.ascii(4);
+    const len = r.u32();
+    r.need(len);
+    const end = r.pos + len;
+    if (key === "samp") {
+      const s = new Reader(r.bytes, end);
+      s.pos = r.pos;
+      while (s.pos + 4 <= end && samples.length < MAX_TIPS) {
+        const size = s.u32();
+        const padded = size + (4 - size % 4) % 4;
+        const next = s.pos + padded;
+        if (s.pos + size > end) break;
+        const b = new Reader(r.bytes, s.pos + size);
+        b.pos = s.pos;
+        try {
+          const keyLen = b.u8();
+          const uuid = b.ascii(keyLen);
+          b.pos = s.pos + (subversion === 1 ? 47 : 301);
+          const top = b.i32();
+          const left = b.i32();
+          const bottom = b.i32();
+          const right = b.i32();
+          const depth = b.u16();
+          const compression = b.u8();
+          const width = right - left;
+          const height = bottom - top;
+          samples.push({ uuid, tip: { kind: "sampled", width, height, mask: readImage(b, width, height, depth, compression) } });
+        } catch (e) {
+          file.unsupported.push(`Sampled tip ${samples.length + 1} could not be read: ${e.message}`);
+        }
+        s.pos = Math.min(next, end);
+      }
+    } else if (key === "desc") presets = readDescriptor(r.bytes.subarray(r.pos, end));
+    else if (key === "patt") file.unsupported.push("Patterns (the brushes' textures) are not imported; add a pattern image as a grain source with add_brush_source.");
+    r.pos = end + len % 2;
+  }
+  for (const { uuid, tip } of samples) {
+    const p = presets.get(uuid);
+    file.tips.push({ ...tip, ...p?.name ? { name: p.name } : {}, ...p?.spacing !== void 0 ? { spacing: p.spacing } : {} });
+  }
+  if (presets.size) file.unsupported.push("Preset dynamics, textures, dual brushes and colour settings are not mapped; each tip imports with its name and spacing.");
+}
+function readAbr(bytes) {
+  const r = new Reader(bytes);
+  let version;
+  try {
+    version = r.u16();
+  } catch {
+    throw new AbrError("Not a brush file: it is empty.");
+  }
+  const file = { version, tips: [], unsupported: [] };
+  try {
+    if (version === 1 || version === 2) readV1(r, version, file);
+    else if (version === 6 || version === 7 || version === 10) {
+      const subversion = r.u16();
+      if (subversion !== 1 && subversion !== 2) throw new AbrError(`ABR version ${version}.${subversion} is not supported.`);
+      readV6(r, subversion, file);
+    } else throw new AbrError(`Not a Photoshop brush file, or ABR version ${version}, which is not supported (1, 2, 6, 7 and 10 are).`);
+  } catch (e) {
+    if (!file.tips.length) throw e instanceof AbrError ? e : new AbrError(e.message);
+    file.unsupported.push(`The rest of the file could not be read: ${e.message}`);
+  }
+  return file;
+}
+
+// src/brushes/import/bplist.ts
+var PlistError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlistError";
+  }
+};
+var MAX_OBJECTS = 2e5;
+var MAX_DEPTH = 64;
+function isBinaryPlist(bytes) {
+  return bytes.length >= 40 && String.fromCharCode(...bytes.subarray(0, 8)) === "bplist00";
+}
+function readBinaryPlist(bytes) {
+  if (!isBinaryPlist(bytes)) throw new PlistError("Not a binary property list.");
+  const t = bytes.length - 32;
+  const offsetSize = bytes[t + 6];
+  const refSize = bytes[t + 7];
+  const uint = (p, n) => {
+    if (p < 0 || p + n > bytes.length) throw new PlistError("A property list offset is out of bounds.");
+    let v = 0;
+    for (let i = 0; i < n; i++) v = v * 256 + bytes[p + i];
+    return v;
+  };
+  const count = uint(t + 8, 8);
+  const top = uint(t + 16, 8);
+  const tableAt = uint(t + 24, 8);
+  if (![1, 2, 4, 8].includes(offsetSize) || ![1, 2, 4, 8].includes(refSize)) throw new PlistError("The property list trailer is malformed.");
+  if (count > MAX_OBJECTS || top >= count || tableAt + count * offsetSize > t) throw new PlistError("The property list is malformed or too large.");
+  const offsetOf = (i) => {
+    if (i >= count) throw new PlistError("A property list reference is out of range.");
+    const o = uint(tableAt + i * offsetSize, offsetSize);
+    if (o >= tableAt) throw new PlistError("A property list object is out of bounds.");
+    return o;
+  };
+  const reading = /* @__PURE__ */ new Set();
+  const read = (index, depth) => {
+    if (depth > MAX_DEPTH) throw new PlistError("The property list is nested too deeply.");
+    if (reading.has(index)) throw new PlistError("The property list refers to itself.");
+    let p = offsetOf(index);
+    const marker = bytes[p];
+    const kind = marker >> 4;
+    let info = marker & 15;
+    p++;
+    const length = () => {
+      if (info !== 15) return info;
+      const m = bytes[p];
+      if (m >> 4 !== 1) throw new PlistError("A property list length is malformed.");
+      const n = 1 << (m & 15);
+      const v = uint(p + 1, n);
+      p += 1 + n;
+      return v;
+    };
+    switch (kind) {
+      case 0:
+        return info === 8 ? false : info === 9 ? true : null;
+      case 1: {
+        const n = 1 << info;
+        if (n === 8) {
+          const v = new DataView(bytes.buffer, bytes.byteOffset + p, 8).getBigInt64(0);
+          return Number(v);
+        }
+        return uint(p, n);
+      }
+      case 2: {
+        const n = 1 << info;
+        if (p + n > bytes.length) throw new PlistError("A property list number is out of bounds.");
+        const view = new DataView(bytes.buffer, bytes.byteOffset + p, n);
+        return n === 4 ? view.getFloat32(0) : n === 8 ? view.getFloat64(0) : 0;
+      }
+      case 3:
+        return p + 8 <= bytes.length ? new DataView(bytes.buffer, bytes.byteOffset + p, 8).getFloat64(0) : 0;
+      case 4: {
+        const n = length();
+        if (p + n > bytes.length) throw new PlistError("Property list data is out of bounds.");
+        return bytes.slice(p, p + n);
+      }
+      case 5: {
+        const n = length();
+        if (p + n > bytes.length) throw new PlistError("A property list string is out of bounds.");
+        return String.fromCharCode(...bytes.subarray(p, p + n));
+      }
+      case 6: {
+        const n = length();
+        if (p + n * 2 > bytes.length) throw new PlistError("A property list string is out of bounds.");
+        let s = "";
+        for (let i = 0; i < n; i++) s += String.fromCharCode(bytes[p + i * 2] << 8 | bytes[p + i * 2 + 1]);
+        return s;
+      }
+      case 8:
+        return { uid: uint(p, info + 1) };
+      case 10:
+      case 12: {
+        const n = length();
+        reading.add(index);
+        const out = [];
+        for (let i = 0; i < n; i++) out.push(read(uint(p + i * refSize, refSize), depth + 1));
+        reading.delete(index);
+        return out;
+      }
+      case 13: {
+        const n = length();
+        reading.add(index);
+        const out = {};
+        for (let i = 0; i < n; i++) {
+          const key = read(uint(p + i * refSize, refSize), depth + 1);
+          if (typeof key !== "string") throw new PlistError("A property list key is not a string.");
+          out[key] = read(uint(p + (n + i) * refSize, refSize), depth + 1);
+        }
+        reading.delete(index);
+        return out;
+      }
+      default:
+        throw new PlistError(`Property list object type ${kind.toString(16)} is not supported.`);
+    }
+  };
+  return read(top, 0);
+}
+function keyedArchiveRoot(plist) {
+  const top = plist;
+  const objects = Array.isArray(top?.$objects) ? top.$objects : null;
+  const root = top?.$top?.root;
+  if (!objects || !root || typeof root !== "object" || !("uid" in root)) return null;
+  const at = (v) => v && typeof v === "object" && "uid" in v && typeof v.uid === "number" ? objects[v.uid] ?? null : v;
+  const obj = at(root);
+  if (!obj || typeof obj !== "object" || Array.isArray(obj) || obj instanceof Uint8Array) return null;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const value = at(v);
+    out[k] = value === "$null" ? null : value;
+  }
+  return out;
+}
+
+// src/brushes/import/zip.ts
+var ZipError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZipError";
+  }
+};
+var u16 = (b, p) => b[p] | b[p + 1] << 8;
+var u32 = (b, p) => (b[p] | b[p + 1] << 8 | b[p + 2] << 16 | b[p + 3] << 24) >>> 0;
+function isZip(bytes) {
+  return bytes.length >= 22 && bytes[0] === 80 && bytes[1] === 75 && (bytes[2] === 3 || bytes[2] === 5) && (bytes[3] === 4 || bytes[3] === 6);
+}
+function readZip(bytes, limits = {}) {
+  const maxEntries = limits.maxEntries ?? 4096;
+  const maxEntry = limits.maxEntrySize ?? 64 * 1024 * 1024;
+  const maxTotal = limits.maxTotalSize ?? 512 * 1024 * 1024;
+  let eocd = -1;
+  for (let p2 = bytes.length - 22; p2 >= Math.max(0, bytes.length - 22 - 65535); p2--) {
+    if (u32(bytes, p2) === 101010256) {
+      eocd = p2;
+      break;
+    }
+  }
+  if (eocd < 0) throw new ZipError("Not a ZIP archive: no end of central directory.");
+  const count = u16(bytes, eocd + 10);
+  const dirSize = u32(bytes, eocd + 12);
+  const dirOffset = u32(bytes, eocd + 16);
+  if (count === 65535 || dirOffset === 4294967295) throw new ZipError("ZIP64 archives are not supported.");
+  if (count > maxEntries) throw new ZipError(`The archive has ${count} entries; at most ${maxEntries} are read.`);
+  if (dirOffset + dirSize > eocd) throw new ZipError("The ZIP central directory is out of bounds.");
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  const entries = [];
+  let total = 0;
+  let p = dirOffset;
+  for (let i = 0; i < count; i++) {
+    if (p + 46 > eocd || u32(bytes, p) !== 33639248) throw new ZipError(`ZIP directory entry ${i} is malformed.`);
+    const flags = u16(bytes, p + 8);
+    const method = u16(bytes, p + 10);
+    const csize = u32(bytes, p + 20);
+    const size = u32(bytes, p + 24);
+    const nameLen = u16(bytes, p + 28);
+    const extraLen = u16(bytes, p + 30);
+    const commentLen = u16(bytes, p + 32);
+    const local = u32(bytes, p + 42);
+    if (p + 46 + nameLen > eocd) throw new ZipError(`ZIP directory entry ${i} is malformed.`);
+    const name = decoder.decode(bytes.subarray(p + 46, p + 46 + nameLen)).replace(/\\/g, "/");
+    p += 46 + nameLen + extraLen + commentLen;
+    if (name.endsWith("/")) continue;
+    if (flags & 1) throw new ZipError(`"${name}" is encrypted; encrypted archives are not supported.`);
+    if (method !== 0 && method !== 8) throw new ZipError(`"${name}" uses compression method ${method}; only stored and deflated files are read.`);
+    if (size > maxEntry) throw new ZipError(`"${name}" is ${size} bytes; files over ${maxEntry} bytes are not read.`);
+    total += size;
+    if (total > maxTotal) throw new ZipError(`The archive unpacks to more than ${maxTotal} bytes.`);
+    if (local + 30 > bytes.length || u32(bytes, local) !== 67324752) throw new ZipError(`"${name}" has no local header.`);
+    const start = local + 30 + u16(bytes, local + 26) + u16(bytes, local + 28);
+    if (start + csize > bytes.length) throw new ZipError(`"${name}" runs past the end of the archive.`);
+    let cached = null;
+    entries.push({
+      name,
+      size,
+      read() {
+        if (cached) return cached;
+        const raw = bytes.subarray(start, start + csize);
+        const out = method === 0 ? raw : inflateRaw(raw, { maxOutput: Math.max(size, 1), sizeHint: size });
+        if (out.length !== size) throw new ZipError(`"${name}" unpacked to ${out.length} bytes, not the ${size} its directory says.`);
+        cached = out;
+        return out;
+      }
+    });
+  }
+  return entries;
+}
+
+// src/brushes/import/pack.ts
+var BRUSH_PACK_FORMATS = ["abr", "brush", "brushset"];
+var MAX_BRUSH_PACK_BYTES = 64 * 1024 * 1024;
+var MAX_PACK_BRUSHES = 300;
+var BrushPackError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrushPackError";
+  }
+};
+var slug = (s, max = 40) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/, "");
+var stem = (fileName) => fileName.replace(/^.*[\\/]/, "").replace(/\.[a-z0-9]+$/i, "");
+var clamp2 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+function brushPackFormat(bytes, fileName, format) {
+  if (format) return format;
+  const ext = /\.([a-z]+)$/i.exec(fileName)?.[1]?.toLowerCase();
+  if (ext === "abr" || ext === "brush" || ext === "brushset") return ext;
+  if (isZip(bytes)) return "brushset";
+  if (bytes.length >= 2 && [1, 2, 6, 7, 10].includes(bytes[0] << 8 | bytes[1])) return "abr";
+  throw new BrushPackError(`"${fileName}" is not a brush pack this reads: give a .abr (Photoshop), .brush or .brushset (Procreate) file.`);
+}
+function idMaker(prefix) {
+  const used = /* @__PURE__ */ new Set();
+  return (name) => {
+    const base = `${prefix}-${slug(name, 20) || "brush"}`.slice(0, 58).replace(/-+$/, "");
+    let id = base;
+    for (let n = 2; used.has(id) || !BRUSH_ID.test(id); n++) id = `${base}-${n}`;
+    used.add(id);
+    return id;
+  };
+}
+function licenceText(name, bytes) {
+  let text = new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(0, 64 * 1024));
+  if (/\.rtf$/i.test(name)) text = text.replace(/\\[a-z]+-?\d* ?|[{}]/gi, "");
+  text = text.replace(/\r\n?/g, "\n").replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+  return text ? `${stem(name)}: ${text.slice(0, 4e3)}` : null;
+}
+var LICENCE_FILE = /(^|\/)[^/]*(licen[cs]e|terms|eula|readme|copyright)[^/]*\.(txt|md|rtf)$/i;
+function readAbrPack(bytes, name, prefix, licence, pack) {
+  const file = readAbr(bytes);
+  pack.unsupported.push(...file.unsupported);
+  const id = idMaker(prefix);
+  file.tips.slice(0, MAX_PACK_BRUSHES).forEach((tip, i) => {
+    const label = tip.name ?? `${name} ${i + 1}`;
+    const brushId = id(tip.name ?? String(i + 1));
+    const base = { id: brushId, name: label.slice(0, 80), kind: "mark", tags: ["imported"], description: `Imported from ${name}.abr.` };
+    if (tip.kind === "computed") {
+      pack.brushes.push({ ...base, tip: { shape: tip.roundness < 1 ? "flat" : "round", size: tip.diameter, hardness: tip.hardness, spacing: tip.spacing, roundness: tip.roundness, angle: tip.angle } });
+      return;
+    }
+    try {
+      const source = brushSourceFromMask({ id: `${brushId}-shape`, name: label, licence, origin: `${name}.abr` }, tip.width, tip.height, tip.mask);
+      pack.sources.push(source);
+      pack.brushes.push({ ...base, tip: { shape: "stamp", size: clamp2(Math.max(tip.width, tip.height), 1, 2500), spacing: tip.spacing ?? 0.25, stamps: [brushSourceRef(source.id)] } });
+    } catch (e) {
+      pack.unsupported.push(`"${label}": ${e.message}`);
+    }
+  });
+  if (file.tips.length > MAX_PACK_BRUSHES) pack.unsupported.push(`Only the first ${MAX_PACK_BRUSHES} of ${file.tips.length} tips were imported.`);
+}
+function readProcreatePack(bytes, name, prefix, licence, pack) {
+  let entries;
+  try {
+    entries = readZip(bytes);
+  } catch (e) {
+    throw new BrushPackError(`"${name}" can't be read as a Procreate brush pack: ${e.message}`);
+  }
+  const byName = new Map(entries.map((e) => [e.name, e]));
+  const found = [];
+  for (const e of entries) {
+    if (!LICENCE_FILE.test(e.name) || e.size > 1024 * 1024) continue;
+    const text = licenceText(e.name, e.read());
+    if (text) found.push(text);
+  }
+  pack.licence.push(...found);
+  const terms = found.length ? found.join("\n\n").slice(0, 2e3) : void 0;
+  const dirs = entries.filter((e) => /(^|\/)Brush\.archive$/.test(e.name)).map((e) => e.name.slice(0, -"Brush.archive".length));
+  if (!dirs.length) throw new BrushPackError(`"${name}" has no Procreate brushes (no Brush.archive inside).`);
+  const id = idMaker(prefix);
+  dirs.slice(0, MAX_PACK_BRUSHES).forEach((dir, i) => {
+    let settings = null;
+    try {
+      const archive = byName.get(`${dir}Brush.archive`).read();
+      if (isBinaryPlist(archive)) settings = keyedArchiveRoot(readBinaryPlist(archive));
+    } catch {
+      settings = null;
+    }
+    const own = typeof settings?.name === "string" && settings.name.trim() ? settings.name.trim() : null;
+    const label = (own ?? (dirs.length === 1 ? name : `${name} ${i + 1}`)).slice(0, 80);
+    const brushId = id(own ?? String(i + 1));
+    const where = `${name}${dir ? `/${dir.replace(/\/$/, "")}` : ""}`;
+    const source = (file, kind) => {
+      const e = byName.get(`${dir}${file}`);
+      if (!e) return null;
+      try {
+        const s = makeBrushSource({ id: `${brushId}-${kind}`, name: `${label} ${kind}`, image: e.read(), channel: "lightness", licence: [licence, terms].filter(Boolean).join("\n\n") || void 0, origin: `${where}/${file}` });
+        pack.sources.push(s);
+        return s;
+      } catch (err) {
+        pack.unsupported.push(`"${label}" ${kind}: ${err.message}`);
+        return null;
+      }
+    };
+    const shape = source("Shape.png", "shape");
+    const grain = source("Grain.png", "grain");
+    const plot = typeof settings?.plotSpacing === "number" && settings.plotSpacing > 0 ? clamp2(settings.plotSpacing, 0.01, 10) : void 0;
+    pack.brushes.push({
+      id: brushId,
+      name: label,
+      kind: "mark",
+      tags: ["imported", "procreate"],
+      description: `Imported from ${name}.`,
+      tip: {
+        shape: shape ? "stamp" : "round",
+        size: 40,
+        ...plot !== void 0 ? { spacing: plot } : {},
+        ...shape ? { stamps: [brushSourceRef(shape.id)] } : {},
+        ...grain ? { grain: { source: brushSourceRef(grain.id), mode: "moving" } } : {}
+      }
+    });
+    if (!settings) pack.unsupported.push(`"${label}": its Brush.archive could not be read; the brush takes its name from the file and default settings.`);
+  });
+  if (dirs.length > MAX_PACK_BRUSHES) pack.unsupported.push(`Only the first ${MAX_PACK_BRUSHES} of ${dirs.length} brushes were imported.`);
+  pack.unsupported.push("Procreate settings other than the name, shape, grain and spacing (dynamics, Apple Pencil curves, taper, wet mix, colour dynamics, rendering modes) are not mapped.");
+}
+function readBrushPack(bytes, options) {
+  if (bytes.length > MAX_BRUSH_PACK_BYTES) throw new BrushPackError(`"${options.fileName}" is ${bytes.length} bytes; packs over ${MAX_BRUSH_PACK_BYTES} bytes are not read.`);
+  const format = brushPackFormat(bytes, options.fileName, options.format);
+  const name = stem(options.fileName) || "Brushes";
+  const prefix = slug(options.prefix ?? name) || "pack";
+  const licence = options.licence?.trim() ? options.licence.trim().slice(0, 2e3) : void 0;
+  const pack = { format, brushes: [], sources: [], unsupported: [], licence: licence ? [licence] : [] };
+  try {
+    if (format === "abr") readAbrPack(bytes, name, prefix, licence, pack);
+    else readProcreatePack(bytes, name, prefix, licence, pack);
+  } catch (e) {
+    throw e instanceof BrushPackError ? e : new BrushPackError(`"${options.fileName}" can't be read: ${e.message}`);
+  }
+  if (!pack.brushes.length) throw new BrushPackError(`"${options.fileName}" has no brushes that can be imported. ${pack.unsupported.join(" ")}`.trim());
+  return pack;
+}
+async function importBrushPack(library, bytes, options) {
+  const pack = readBrushPack(bytes, options);
+  const r = await library.importFile({ format: "pixerate-brushes", version: 2, brushes: pack.brushes, sources: pack.sources }, { overwrite: !!options.overwrite });
+  const done = /* @__PURE__ */ new Set([...r.added, ...r.replaced]);
+  return {
+    format: pack.format,
+    brushes: pack.brushes.filter((b) => done.has(b.id)).map((b) => ({ id: b.id, name: b.name })),
+    sources: r.sources ?? [],
+    skipped: r.skipped,
+    unsupported: pack.unsupported,
+    licence: pack.licence,
+    problems: r.problems
+  };
+}
+async function importBrushFile(library, file, options = {}) {
+  if (/\.json$/i.test(file.name)) {
+    let raw;
+    try {
+      raw = JSON.parse(await file.text());
+    } catch {
+      throw new BrushPackError(`"${file.name}" is not JSON.`);
+    }
+    return library.importFile(raw, { overwrite: !!options.overwrite });
+  }
+  return importBrushPack(library, new Uint8Array(await file.arrayBuffer()), { fileName: file.name, ...options });
+}
+
 // src/brushes/tools.ts
 var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
@@ -402,6 +1043,42 @@ function createBrushLibraryTools(library, options = {}) {
       },
       annotations: { title: "Import brushes", ...WRITE, destructiveHint: true },
       handler: async ({ file, overwrite }) => library.importFile(file, { overwrite: !!overwrite })
+    },
+    {
+      name: "import_brush_pack",
+      title: "Import a brush pack",
+      description: `Imports a brush pack someone already owns: Photoshop .abr (sampled tips become image sources and stamp-tip brushes, computed tips round or flat brushes; preset names and spacing where the file has them) or Procreate .brush / .brushset (each brush's shape becomes its image tip and its grain its tip grain, with its name and spacing). Brushes and sources are added to the library in one import; ids already saved are skipped unless overwrite. Returns format, brushes (id, name, renderable: whether this host, ${profile.name}, can paint it), sources (ids), skipped, unsupported (what was not imported or mapped, in words), licence (the licence given and any licence or terms files found in the pack, also kept on each source) and problems. Packs are often licensed for personal use only: pass the licence they came with.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          file: { type: "string", minLength: 4, maxLength: Math.ceil(MAX_BRUSH_PACK_BYTES * 4 / 3) + 4, description: `The pack's bytes, base64 (at most ${MAX_BRUSH_PACK_BYTES / 1024 / 1024} MB).` },
+          fileName: { type: "string", minLength: 1, maxLength: 200, description: 'The file name, e.g. "Inky.abr": its extension picks the format and its name prefixes the brush ids and names.' },
+          format: { type: "string", enum: [...BRUSH_PACK_FORMATS], description: "abr, brush or brushset (default: from the file name, then the contents)." },
+          prefix: { type: "string", pattern: "^[a-z0-9][a-z0-9-]{0,39}$", description: "Id prefix for the brushes and sources (default: from the file name)." },
+          licence: { type: "string", maxLength: 2e3, description: "The licence or terms the pack came with, kept on every source it adds." },
+          overwrite: { type: "boolean", description: "Replace saved brushes and sources with the same ids (default false: skip them)." }
+        },
+        required: ["file", "fileName"],
+        additionalProperties: false
+      },
+      annotations: { title: "Import a brush pack", ...WRITE, destructiveHint: true },
+      handler: async ({ file, fileName, format, prefix, licence, overwrite }) => {
+        let bytes;
+        try {
+          bytes = base64ToBytes(file.replace(/^data:[^,]*,/, ""));
+        } catch {
+          throw new BrushLibraryError("invalid", "file is not base64: pass the pack's bytes as base64 (a data: URL works too).");
+        }
+        let r;
+        try {
+          r = await importBrushPack(library, bytes, { fileName, ...format ? { format } : {}, ...prefix ? { prefix } : {}, ...licence ? { licence } : {}, overwrite: !!overwrite });
+        } catch (e) {
+          if (e instanceof BrushLibraryError) throw e;
+          throw new BrushLibraryError("invalid", `${e.message} Nothing was imported.`);
+        }
+        const entries = await Promise.all(r.brushes.map((b) => library.get(b.id)));
+        return { ...r, brushes: r.brushes.map((b, i) => ({ ...b, renderable: entries[i] ? checkBrush(entries[i].brush, profile).ok : false })) };
+      }
     }
   );
   return tools;
@@ -594,6 +1271,16 @@ export {
   BRUSH_UNSET_PROPERTY,
   mergeBrushPatch,
   changedBrushPaths,
+  AbrError,
+  readAbr,
+  BRUSH_PACK_FORMATS,
+  MAX_BRUSH_PACK_BYTES,
+  MAX_PACK_BRUSHES,
+  BrushPackError,
+  brushPackFormat,
+  readBrushPack,
+  importBrushPack,
+  importBrushFile,
   createBrushLibraryTools,
   createBrushLibraryToolProvider,
   BRUSH_SLIDERS,