@pixerate/editor 0.51.0 → 0.53.0

package/dist/{chunk-GJBIVWB2.js → chunk-3S72F46R.js}

@@ -6,7 +6,7 @@ import {
   isCartesianChart,
   normalizeChartSpec,
   parseChartColor
-} from "./chunk-OV7UAKIY.js";
+} from "./chunk-633QC34G.js";
 
 // src/chart/ooxml.ts
 var CHART_OOXML_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
@@ -81,6 +81,27 @@ var MARKERS = { circle: "circle", dot: "circle", square: "square", diamond: "dia
 var TREND_IN = { linear: "linear", exp: "exponential", log: "logarithmic", poly: "polynomial", power: "power", movingAvg: "moving-average" };
 var TREND_OUT = { linear: "linear", exponential: "exp", logarithmic: "log", polynomial: "poly", power: "power", "moving-average": "movingAvg" };
 var LEGEND_IN = { b: "bottom", t: "top", l: "left", r: "right", tr: "right" };
+var ERR_IN = { fixedVal: "fixed", percentage: "percent", stdDev: "stddev", stdErr: "stderr", cust: "custom" };
+var ERR_OUT = { fixed: "fixedVal", percent: "percentage", stddev: "stdDev", stderr: "stdErr", custom: "cust" };
+function readErrorBars(e) {
+  const type = ERR_IN[val(e, "errValType") ?? "fixedVal"];
+  if (!type) return null;
+  const bars = { type };
+  const value = numberOf(val(e, "val"));
+  if (value !== null && type !== "custom" && type !== "stderr") bars.value = Math.abs(value);
+  if (type === "custom") {
+    const plus = kid(e, "plus");
+    const minus = kid(e, "minus");
+    const p = plus ? numbers(plus).map((v) => v === null ? null : Math.abs(v)) : [];
+    const m = minus ? numbers(minus).map((v) => v === null ? null : Math.abs(v)) : [];
+    if (p.some((v) => v !== null)) bars.plus = p;
+    if (m.some((v) => v !== null) && JSON.stringify(m) !== JSON.stringify(p)) bars.minus = m;
+  }
+  const direction = val(e, "errBarType");
+  if (direction === "plus" || direction === "minus") bars.direction = direction;
+  if (bool(val(e, "noEndCap"))) bars.cap = false;
+  return bars;
+}
 function chartFromOoxml(xml, options = {}) {
   const issues = [];
   const unsupported = [];
@@ -240,7 +261,18 @@ function chartFromOoxml(xml, options = {}) {
         trends.push(line);
       }
       if (trends.length) out.trendlines = trends;
-      if (kids(s, "errBars").length) unsupported.push("error bars");
+      for (const e of kids(s, "errBars")) {
+        const bars = readErrorBars(e);
+        if (!bars) {
+          unsupported.push(`error bars of type "${val(e, "errValType")}"`);
+          continue;
+        }
+        if (val(e, "errDir") === "x") {
+          if (type === "scatter" || type === "bubble") out.xErrorBars = bars;
+          else unsupported.push("x error bars on a category chart");
+        } else if (type === "pie" || type === "donut" || type === "radar") unsupported.push(`error bars on a ${type} chart`);
+        else out.errorBars = bars;
+      }
       series.push(out);
     }
   }
@@ -273,8 +305,15 @@ function chartFromOoxml(xml, options = {}) {
     const scaling = kid(a, "scaling");
     axis.min = numberOf(val(scaling, "min"));
     axis.max = numberOf(val(scaling, "max"));
-    if (val(scaling, "orientation") === "maxMin") unsupported.push("a reversed axis");
-    if (kid(scaling, "logBase")) unsupported.push("a logarithmic axis");
+    if (val(scaling, "orientation") === "maxMin") axis.reverse = true;
+    if (kid(scaling, "logBase")) {
+      if (a.localName !== "valAx") unsupported.push("a logarithmic category axis");
+      else {
+        axis.scale = "log";
+        const base = numberOf(val(scaling, "logBase")) ?? 10;
+        if (base !== 10) axis.logBase = base;
+      }
+    }
     axis.step = numberOf(val(a, "majorUnit"));
     const fmt = kid(a, "numFmt");
     const code = fmt?.getAttribute("formatCode");
@@ -384,6 +423,14 @@ function chartFormatToCode(format) {
       return d !== void 0 || format.prefix || format.suffix ? wrap(`#,##0${frac(d, 0)}`) : "General";
   }
 }
+function errBarsXml(bars, dir) {
+  let x = `<c:errBars>${dir ? `<c:errDir val="${dir}"/>` : ""}<c:errBarType val="${bars.direction ?? "both"}"/><c:errValType val="${ERR_OUT[bars.type]}"/><c:noEndCap val="${bars.cap === false ? 1 : 0}"/>`;
+  if (bars.type === "custom") {
+    const plus = bars.plus ?? (bars.minus ?? []).map(() => null);
+    x += `<c:plus>${numLit(plus)}</c:plus><c:minus>${numLit(bars.minus ?? plus)}</c:minus>`;
+  } else if (bars.type !== "stderr") x += `<c:val val="${bars.value ?? (bars.type === "percent" ? 5 : 1)}"/>`;
+  return `${x}</c:errBars>`;
+}
 var MARKER_OUT = { circle: "circle", square: "square", diamond: "diamond", triangle: "triangle", cross: "x", none: "none" };
 function chartToOoxml(spec) {
   const issues = [];
@@ -442,6 +489,14 @@ function chartToOoxml(spec) {
         x += `<c:dispRSqr val="${t.showR2 ? 1 : 0}"/><c:dispEq val="${t.showEquation ? 1 : 0}"/></c:trendline>`;
         parts.push(x);
       }
+    if (!pieLike && kind !== "radar") {
+      const xyKind = kind === "scatter" || kind === "bubble";
+      if (s.errorBars) parts.push(errBarsXml(s.errorBars, xyKind ? "y" : null));
+      if (s.xErrorBars) {
+        if (xyKind) parts.push(errBarsXml(s.xErrorBars, "x"));
+        else issues.push(`"${s.name}" has x error bars, which only scatter and bubble charts can hold; they are left out.`);
+      }
+    } else if (s.errorBars || s.xErrorBars) issues.push(`Error bars on "${s.name}" are left out: ${kind} charts cannot show them.`);
     const valCode = chartFormatToCode(s.format ?? (s.axis === "secondary" ? spec.yAxis2.format : spec.yAxis.format));
     if (kind === "scatter" || kind === "bubble") {
       const xs = s.x ?? spec.categories.map((_, i) => i + 1);
@@ -484,7 +539,7 @@ function chartToOoxml(spec) {
         return `<c:pieChart><c:varyColors val="1"/>${sers}${dLbls}<c:firstSliceAng val="0"/></c:pieChart>`;
     }
   });
-  const scaling = (a) => `<c:scaling><c:orientation val="minMax"/>${a.max !== null ? `<c:max val="${a.max}"/>` : ""}${a.min !== null ? `<c:min val="${a.min}"/>` : ""}</c:scaling>`;
+  const scaling = (a) => `<c:scaling>${a.scale === "log" ? `<c:logBase val="${a.logBase ?? 10}"/>` : ""}<c:orientation val="${a.reverse ? "maxMin" : "minMax"}"/>${a.max !== null ? `<c:max val="${a.max}"/>` : ""}${a.min !== null ? `<c:min val="${a.min}"/>` : ""}</c:scaling>`;
   const title = (a) => a.title ? `<c:title>${rich(a.title)}</c:title>` : "";
   const fmt = (a) => {
     const code = chartFormatToCode(a.format);
@@ -494,11 +549,14 @@ function chartToOoxml(spec) {
   const catPos = horizontal ? "l" : "b";
   const valPos = horizontal ? "b" : "l";
   const valAx = (id, cross, a, pos, crosses, catKind = false) => `<c:valAx><c:axId val="${id}"/>${scaling(a)}<c:delete val="${a.show ? 0 : 1}"/><c:axPos val="${pos}"/>${a.gridlines ? "<c:majorGridlines/>" : ""}${title(a)}${fmt(a)}<c:majorTickMark val="out"/><c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/><c:crossAx val="${cross}"/><c:crosses val="${crosses}"/><c:crossBetween val="${catKind ? "midCat" : "between"}"/>${a.step ? `<c:majorUnit val="${a.step}"/>` : ""}</c:valAx>`;
-  const catAx = (id, cross, a, pos, hidden = false) => `<c:${a.kind === "date" ? "dateAx" : "catAx"}><c:axId val="${id}"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="${a.show && !hidden ? 0 : 1}"/><c:axPos val="${pos}"/>${a.gridlines ? "<c:majorGridlines/>" : ""}${title(a)}<c:numFmt formatCode="General" sourceLinked="1"/><c:majorTickMark val="out"/><c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/><c:crossAx val="${cross}"/><c:crosses val="autoZero"/><c:auto val="1"/>${a.kind === "date" ? '<c:lblOffset val="100"/><c:baseTimeUnit val="days"/>' : '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/>'}</c:${a.kind === "date" ? "dateAx" : "catAx"}>`;
+  const catAx = (id, cross, a, pos, hidden = false) => `<c:${a.kind === "date" ? "dateAx" : "catAx"}><c:axId val="${id}"/><c:scaling><c:orientation val="${a.reverse ? "maxMin" : "minMax"}"/></c:scaling><c:delete val="${a.show && !hidden ? 0 : 1}"/><c:axPos val="${pos}"/>${a.gridlines ? "<c:majorGridlines/>" : ""}${title(a)}<c:numFmt formatCode="General" sourceLinked="1"/><c:majorTickMark val="out"/><c:minorTickMark val="none"/><c:tickLblPos val="nextTo"/><c:crossAx val="${cross}"/><c:crosses val="autoZero"/><c:auto val="1"/>${a.kind === "date" ? '<c:lblOffset val="100"/><c:baseTimeUnit val="days"/>' : '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/>'}</c:${a.kind === "date" ? "dateAx" : "catAx"}>`;
   let axes = "";
   if (!pieLike) {
     if (xy) axes = valAx(ids.cat, ids.val, spec.xAxis, "b", "autoZero", true) + valAx(ids.val, ids.cat, spec.yAxis, "l", "autoZero", true);
-    else axes = catAx(ids.cat, ids.val, spec.xAxis, catPos) + valAx(ids.val, ids.cat, spec.yAxis, valPos, "autoZero");
+    else {
+      if (spec.xAxis.scale === "log") issues.push("The category axis cannot be logarithmic; its log scale is left out.");
+      axes = catAx(ids.cat, ids.val, spec.xAxis, catPos) + valAx(ids.val, ids.cat, spec.yAxis, valPos, "autoZero");
+    }
     if (groups.some((g) => g.secondary)) axes += catAx(ids.cat2, ids.val2, spec.xAxis, catPos, true) + valAx(ids.val2, ids.cat2, spec.yAxis2, horizontal ? "t" : "r", "max");
   }
   const legendPos = { bottom: "b", top: "t", left: "l", right: "r" }[spec.legend.position];
@@ -510,12 +568,332 @@ function chartToOoxml(spec) {
   return { xml, issues: [...new Set(issues)] };
 }
 
+// src/import/zip.ts
+var ZipError = class extends Error {
+  code;
+  entryName;
+  constructor(code, message, details = {}) {
+    super(message, details.cause !== void 0 ? { cause: details.cause } : void 0);
+    this.name = "ZipError";
+    this.code = code;
+    this.entryName = details.entryName;
+  }
+};
+var DEFAULT_ZIP_MAX_ENTRIES = 1e4;
+var DEFAULT_ZIP_MAX_TOTAL_SIZE = 256 * 1024 * 1024;
+var SIG_EOCD = 101010256;
+var SIG_ZIP64_EOCD = 101075792;
+var SIG_ZIP64_LOCATOR = 117853008;
+var SIG_CENTRAL = 33639248;
+var SIG_LOCAL = 67324752;
+var EOCD_SIZE = 22;
+var MAX_COMMENT = 65535;
+var crcTable = null;
+function zipCrc32(data) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      crcTable[n] = c >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) crc = crcTable[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function toBytes(data) {
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return new Uint8Array(data);
+}
+function isUnsafeZipPath(name) {
+  if (!name || name.includes("\0")) return true;
+  const normalized = name.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized)) return true;
+  return normalized.split("/").some((segment) => segment === "..");
+}
+var utf8 = new TextDecoder("utf-8");
+var CP437_HIGH = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+function decodeName(bytes, isUtf8) {
+  if (isUtf8 || bytes.every((b) => b < 128)) return utf8.decode(bytes);
+  let out = "";
+  for (const b of bytes) out += b < 128 ? String.fromCharCode(b) : CP437_HIGH[b - 128];
+  return out;
+}
+var ZipArchive = class {
+  constructor(bytes, entries, maxTotalSize) {
+    this.bytes = bytes;
+    this.maxTotalSize = maxTotalSize;
+    this.entries = entries;
+    entries.forEach((entry) => {
+      if (!this.byName.has(entry.name)) this.byName.set(entry.name, entry);
+    });
+  }
+  bytes;
+  maxTotalSize;
+  /** Entries in central-directory order. */
+  entries;
+  byName = /* @__PURE__ */ new Map();
+  extracted = 0;
+  /** Looks up an entry by exact name (a leading `/` is ignored). */
+  get(name) {
+    return this.byName.get(name.replace(/^\/+/, ""));
+  }
+  has(name) {
+    return !!this.get(name);
+  }
+  /** Uncompressed bytes extracted so far (counted against `maxTotalSize`). */
+  get extractedSize() {
+    return this.extracted;
+  }
+  /** Extracts an entry's data, verifying its size and CRC-32. */
+  async read(entryOrName) {
+    const entry = typeof entryOrName === "string" ? this.get(entryOrName) : entryOrName;
+    if (!entry) {
+      throw new ZipError("entry_not_found", `ZIP entry "${String(entryOrName)}" not found.`, {
+        entryName: String(entryOrName)
+      });
+    }
+    const name = entry.name;
+    if (entry.encrypted) {
+      throw new ZipError("encrypted", `ZIP entry "${name}" is encrypted; encrypted archives are not supported.`, {
+        entryName: name
+      });
+    }
+    if (entry.isDirectory) return new Uint8Array(0);
+    const remaining = this.maxTotalSize - this.extracted;
+    if (entry.size > remaining) {
+      throw new ZipError(
+        "too_large",
+        `Extracting "${name}" (${entry.size} bytes) would exceed the ${this.maxTotalSize}-byte limit.`,
+        { entryName: name }
+      );
+    }
+    const { bytes } = this;
+    const offset = entry.localHeaderOffset;
+    if (offset + 30 > bytes.length || readU32(bytes, offset) !== SIG_LOCAL) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" has no valid local header.`, { entryName: name });
+    }
+    const dataStart = offset + 30 + readU16(bytes, offset + 26) + readU16(bytes, offset + 28);
+    const dataEnd = dataStart + entry.compressedSize;
+    if (dataEnd > bytes.length) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" is truncated.`, { entryName: name });
+    }
+    const raw = bytes.subarray(dataStart, dataEnd);
+    let data;
+    if (entry.method === 0) {
+      if (entry.compressedSize !== entry.size) {
+        throw new ZipError("corrupt_entry", `Stored ZIP entry "${name}" has inconsistent sizes.`, { entryName: name });
+      }
+      data = raw.slice();
+    } else if (entry.method === 8) {
+      data = await inflateRaw(raw, entry.size, name);
+    } else {
+      throw new ZipError(
+        "unsupported_feature",
+        `ZIP entry "${name}" uses unsupported compression method ${entry.method}; only stored and deflate are supported.`,
+        { entryName: name }
+      );
+    }
+    if (data.length !== entry.size) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" size does not match the directory.`, { entryName: name });
+    }
+    this.extracted += data.length;
+    if (zipCrc32(data) !== entry.crc32) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" failed its CRC-32 check.`, { entryName: name });
+    }
+    return data;
+  }
+  /** Extracts an entry and decodes it as UTF-8 (a leading BOM is removed). */
+  async readText(entryOrName) {
+    const text = utf8.decode(await this.read(entryOrName));
+    return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  }
+};
+function readU16(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8;
+}
+function readU32(bytes, offset) {
+  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function readU64(bytes, offset) {
+  const value = readU32(bytes, offset) + readU32(bytes, offset + 4) * 4294967296;
+  if (!Number.isSafeInteger(value)) {
+    throw new ZipError("unsupported_feature", "ZIP64 value exceeds the supported range.");
+  }
+  return value;
+}
+async function inflateRaw(raw, limit, entryName) {
+  const Stream = globalThis.DecompressionStream;
+  if (typeof Stream !== "function") {
+    throw new ZipError(
+      "unsupported_environment",
+      "Inflating ZIP entries needs DecompressionStream (modern browsers, Node 18+).",
+      { entryName }
+    );
+  }
+  const stream = new Stream("deflate-raw");
+  const writer = stream.writable.getWriter();
+  const reader = stream.readable.getReader();
+  const CHUNK = 64 * 1024;
+  const feeding = (async () => {
+    for (let i = 0; i < raw.length; i += CHUNK) await writer.write(raw.subarray(i, i + CHUNK));
+    await writer.close();
+  })();
+  feeding.catch(() => {
+  });
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > limit) {
+        throw new ZipError(
+          "corrupt_entry",
+          `ZIP entry "${entryName}" inflates beyond its declared size of ${limit} bytes.`,
+          { entryName }
+        );
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    reader.cancel().catch(() => {
+    });
+    writer.abort().catch(() => {
+    });
+    if (error instanceof ZipError) throw error;
+    throw new ZipError("corrupt_entry", `ZIP entry "${entryName}" has an invalid deflate stream.`, {
+      entryName,
+      cause: error
+    });
+  }
+  await feeding.catch(() => {
+  });
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, pos);
+    pos += chunk.length;
+  }
+  return out;
+}
+function findEndOfCentralDirectory(bytes) {
+  const min = Math.max(0, bytes.length - EOCD_SIZE - MAX_COMMENT);
+  for (let i = bytes.length - EOCD_SIZE; i >= min; i--) {
+    if (readU32(bytes, i) === SIG_EOCD && i + EOCD_SIZE + readU16(bytes, i + 20) <= bytes.length) return i;
+  }
+  return -1;
+}
+async function readZip(data, options = {}) {
+  const bytes = toBytes(data);
+  const maxEntries = options.maxEntries ?? DEFAULT_ZIP_MAX_ENTRIES;
+  const maxTotalSize = options.maxTotalSize ?? DEFAULT_ZIP_MAX_TOTAL_SIZE;
+  const eocd = findEndOfCentralDirectory(bytes);
+  if (eocd < 0) throw new ZipError("invalid_archive", "Not a ZIP archive (no end of central directory record).");
+  let diskNumber = readU16(bytes, eocd + 4);
+  let cdDisk = readU16(bytes, eocd + 6);
+  let count = readU16(bytes, eocd + 10);
+  let cdSize = readU32(bytes, eocd + 12);
+  let cdOffset = readU32(bytes, eocd + 16);
+  if (count === 65535 || cdSize === 4294967295 || cdOffset === 4294967295) {
+    const locator = eocd - 20;
+    if (locator < 0 || readU32(bytes, locator) !== SIG_ZIP64_LOCATOR) {
+      throw new ZipError("invalid_archive", "ZIP64 archive is missing its end of central directory locator.");
+    }
+    const record = readU64(bytes, locator + 8);
+    if (record + 56 > bytes.length || readU32(bytes, record) !== SIG_ZIP64_EOCD) {
+      throw new ZipError("invalid_archive", "ZIP64 end of central directory record not found.");
+    }
+    diskNumber = readU32(bytes, record + 16);
+    cdDisk = readU32(bytes, record + 20);
+    count = readU64(bytes, record + 32);
+    cdSize = readU64(bytes, record + 40);
+    cdOffset = readU64(bytes, record + 48);
+  }
+  if (diskNumber !== 0 || cdDisk !== 0) {
+    throw new ZipError("unsupported_feature", "Multi-disk (spanned) ZIP archives are not supported.");
+  }
+  if (count > maxEntries) {
+    throw new ZipError("too_many_entries", `ZIP archive has ${count} entries; the limit is ${maxEntries}.`);
+  }
+  if (cdOffset + cdSize > bytes.length) {
+    throw new ZipError("invalid_archive", "ZIP central directory lies outside the file.");
+  }
+  const entries = [];
+  let p = cdOffset;
+  for (let i = 0; i < count; i++) {
+    if (p + 46 > bytes.length || readU32(bytes, p) !== SIG_CENTRAL) {
+      throw new ZipError("invalid_archive", "ZIP central directory is corrupt.");
+    }
+    const flags = readU16(bytes, p + 8);
+    const method = readU16(bytes, p + 10);
+    const crc32 = readU32(bytes, p + 16);
+    let compressedSize = readU32(bytes, p + 20);
+    let size = readU32(bytes, p + 24);
+    const nameLength = readU16(bytes, p + 28);
+    const extraLength = readU16(bytes, p + 30);
+    const commentLength = readU16(bytes, p + 32);
+    let localHeaderOffset = readU32(bytes, p + 42);
+    const nameStart = p + 46;
+    const extraStart = nameStart + nameLength;
+    const next = extraStart + extraLength + commentLength;
+    if (next > bytes.length) throw new ZipError("invalid_archive", "ZIP central directory is truncated.");
+    for (let e = extraStart; e + 4 <= extraStart + extraLength; ) {
+      const id = readU16(bytes, e);
+      const len = readU16(bytes, e + 2);
+      if (id === 1) {
+        let f = e + 4;
+        const end = f + len;
+        if (size === 4294967295 && f + 8 <= end) {
+          size = readU64(bytes, f);
+          f += 8;
+        }
+        if (compressedSize === 4294967295 && f + 8 <= end) {
+          compressedSize = readU64(bytes, f);
+          f += 8;
+        }
+        if (localHeaderOffset === 4294967295 && f + 8 <= end) localHeaderOffset = readU64(bytes, f);
+      }
+      e += 4 + len;
+    }
+    const rawName = decodeName(bytes.subarray(nameStart, extraStart), (flags & 2048) !== 0);
+    const name = rawName.replace(/\\/g, "/");
+    p = next;
+    if (isUnsafeZipPath(rawName)) {
+      if (options.unsafePaths === "skip") continue;
+      throw new ZipError("unsafe_path", `ZIP entry name "${rawName}" is absolute or escapes the archive root.`, {
+        entryName: rawName
+      });
+    }
+    entries.push({
+      name,
+      isDirectory: name.endsWith("/"),
+      encrypted: (flags & 1) !== 0,
+      method,
+      compressedSize,
+      size,
+      crc32,
+      localHeaderOffset
+    });
+  }
+  return new ZipArchive(bytes, entries, maxTotalSize);
+}
+
 export {
   CHART_OOXML_NS,
   CHART_OOXML_CONTENT_TYPE,
   CHART_OOXML_RELATIONSHIP,
   chartFromOoxml,
   chartFormatToCode,
-  chartToOoxml
+  chartToOoxml,
+  ZipError,
+  DEFAULT_ZIP_MAX_ENTRIES,
+  DEFAULT_ZIP_MAX_TOTAL_SIZE,
+  zipCrc32,
+  isUnsafeZipPath,
+  ZipArchive,
+  readZip
 };
-//# sourceMappingURL=chunk-GJBIVWB2.js.map
+//# sourceMappingURL=chunk-3S72F46R.js.map