@pixerate/editor 0.24.0 → 0.26.0

package/dist/chunk-MR2764X2.js

@@ -0,0 +1,831 @@
+// src/extensions/paragraph-styles/registry.ts
+var MAX_CHAIN = 32;
+var STYLE_ID = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+var UNSAFE_CSS = /[;{}<>\\]|\/\*|url\s*\(|expression\s*\(|@import|javascript:/i;
+var NORMAL_STYLE_ID = "Normal";
+var PREVIEW_PROPERTIES = /* @__PURE__ */ new Set([
+  "font-family",
+  "font-weight",
+  "font-style",
+  "color",
+  "text-decoration-line",
+  "text-transform",
+  "letter-spacing",
+  "font-variant-caps"
+]);
+function isValidStyleId(id) {
+  return typeof id === "string" && STYLE_ID.test(id);
+}
+var MUTED = "var(--pixerate-style-muted, #6b7280)";
+var HEADING_SIZES = ["2em", "1.5em", "1.25em", "1.1em", "1em", "0.9em"];
+function builtinStyles() {
+  const styles = [
+    {
+      id: NORMAL_STYLE_ID,
+      name: "Normal",
+      kind: "paragraph",
+      block: { type: "paragraph" },
+      priority: 0,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Title",
+      name: "Title",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: "TitleChar",
+      paragraph: { spaceAfter: "0.25em", lineHeight: "1.15" },
+      character: { fontSize: "2.5em", bold: true, letterSpacing: "-0.01em" },
+      priority: 10,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Subtitle",
+      name: "Subtitle",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: "SubtitleChar",
+      paragraph: { spaceAfter: "0.75em" },
+      character: { fontSize: "1.25em", color: MUTED },
+      priority: 11,
+      quick: true,
+      builtin: true
+    }
+  ];
+  HEADING_SIZES.forEach((fontSize, i) => {
+    const level = i + 1;
+    styles.push({
+      id: `Heading${level}`,
+      name: `Heading ${level}`,
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: `Heading${level}Char`,
+      block: { type: "heading", attrs: { level } },
+      paragraph: { spaceBefore: level <= 2 ? "1em" : "0.75em", spaceAfter: "0.25em" },
+      character: { fontSize, bold: true },
+      priority: 11 + level,
+      quick: level <= 3,
+      builtin: true
+    });
+  });
+  styles.push(
+    {
+      id: "Quote",
+      name: "Quote",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: "QuoteChar",
+      paragraph: { indentLeft: "1em", paddingLeft: "0.75em", borderLeft: "3px solid currentColor" },
+      character: { italic: true, color: MUTED },
+      priority: 29,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Code",
+      name: "Code",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      block: { type: "codeBlock" },
+      character: {
+        fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+        fontSize: "0.9em"
+      },
+      priority: 30,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "ListParagraph",
+      name: "List Paragraph",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      paragraph: { indentLeft: "2em" },
+      priority: 34,
+      quick: true,
+      builtin: true
+    }
+  );
+  const linked = ["Title", "Subtitle", "Quote", ...HEADING_SIZES.map((_, i) => `Heading${i + 1}`)];
+  linked.forEach((paragraphId) => {
+    const name = styles.find((s) => s.id === paragraphId).name;
+    styles.push({
+      id: `${paragraphId}Char`,
+      name: `${name} Char`,
+      kind: "character",
+      linked: paragraphId,
+      priority: 99,
+      hidden: true,
+      builtin: true
+    });
+  });
+  styles.push(
+    {
+      id: "Emphasis",
+      name: "Emphasis",
+      kind: "character",
+      character: { italic: true },
+      priority: 20,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Strong",
+      name: "Strong",
+      kind: "character",
+      character: { bold: true },
+      priority: 22,
+      quick: true,
+      builtin: true
+    }
+  );
+  return styles;
+}
+var DEFAULT_STYLES = Object.freeze(builtinStyles());
+var clone = (value) => value === void 0 ? value : JSON.parse(JSON.stringify(value));
+function overlay(base, patch) {
+  if (!patch) return base;
+  const out = { ...base };
+  Object.entries(patch).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) out[key] = value;
+  });
+  return out;
+}
+function sameBlock(a, type, attrs) {
+  if (a.type !== type) return false;
+  return Object.entries(a.attrs ?? {}).every(([key, value]) => attrs[key] === value);
+}
+var StyleRegistry = class {
+  styles = /* @__PURE__ */ new Map();
+  defaults;
+  version = 0;
+  snapshot = null;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.defaults = clone(options.defaults ?? {});
+    if (options.builtins !== false) DEFAULT_STYLES.forEach((style) => this.styles.set(style.id, clone(style)));
+    (options.styles ?? []).forEach((style) => this.put(style));
+  }
+  // -- Reading --------------------------------------------------------------
+  get(id) {
+    return id ? this.styles.get(id) : void 0;
+  }
+  /** Finds a style by id or display name (case-insensitive). */
+  find(nameOrId) {
+    const direct = this.styles.get(nameOrId);
+    if (direct) return direct;
+    const lower = nameOrId.toLowerCase();
+    return this.list().find((style) => style.name.toLowerCase() === lower);
+  }
+  /** All styles (optionally of one kind) in gallery order. */
+  list(kind) {
+    return Array.from(this.styles.values()).filter((style) => !kind || style.kind === kind).sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99) || a.name.localeCompare(b.name));
+  }
+  /** Styles shown in the gallery (`quick`, not hidden), paragraph styles by default. */
+  gallery(kind = "paragraph") {
+    return this.list(kind).filter((style) => style.quick && !style.hidden);
+  }
+  /** The `basedOn` chain from the root style down to `id` (cycle-safe, bounded). */
+  chain(id) {
+    const out = [];
+    let current = this.styles.get(id);
+    while (current && out.length < MAX_CHAIN && !out.includes(current)) {
+      out.push(current);
+      current = current.basedOn ? this.styles.get(current.basedOn) : void 0;
+    }
+    return out.reverse();
+  }
+  /**
+   * Resolves a paragraph style: defaults, then each style of the chain (base
+   * first). Unknown ids resolve to the defaults in a `paragraph` block.
+   */
+  resolve(id) {
+    let paragraph = overlay({}, this.defaults.paragraph);
+    let character = overlay({}, this.defaults.character);
+    let block = { type: "paragraph" };
+    this.chain(id).forEach((style) => {
+      if (style.kind !== "paragraph") return;
+      paragraph = overlay(paragraph, style.paragraph);
+      character = overlay(character, style.character);
+      if (style.block) block = clone(style.block);
+    });
+    return { id, paragraph, character, block, next: this.nextStyleId(id) };
+  }
+  /** Character formatting a paragraph style's chain sets (without defaults). */
+  paragraphCharacter(id) {
+    let character = {};
+    this.chain(id).forEach((style) => {
+      if (style.kind === "paragraph") character = overlay(character, style.character);
+    });
+    return character;
+  }
+  /**
+   * Character formatting of a character style's chain. A style linked to a
+   * paragraph style takes that style's character formatting first.
+   */
+  resolveCharacterStyle(id) {
+    let character = {};
+    this.chain(id).forEach((style) => {
+      if (style.kind === "character" && style.linked && this.get(style.linked)?.kind === "paragraph") {
+        character = overlay(character, this.paragraphCharacter(style.linked));
+      }
+      character = overlay(character, style.character);
+    });
+    return character;
+  }
+  /**
+   * Character formatting of text: defaults → paragraph style chain →
+   * character style chain → direct formatting.
+   */
+  resolveText(input) {
+    let character = this.resolve(input.paragraphStyle || NORMAL_STYLE_ID).character;
+    if (input.characterStyle) character = overlay(character, this.resolveCharacterStyle(input.characterStyle));
+    return overlay(character, input.direct);
+  }
+  /** The style after Enter at the end of a paragraph of `id` (itself when unset or unknown). */
+  nextStyleId(id) {
+    const next = this.styles.get(id)?.next;
+    return next && this.styles.get(next)?.kind === "paragraph" ? next : id;
+  }
+  /** The linked character style of a paragraph style, if any. */
+  linkedCharacterStyle(id) {
+    const style = this.styles.get(id);
+    const linked = style?.linked ? this.styles.get(style.linked) : void 0;
+    return style?.kind === "paragraph" && linked?.kind === "character" ? linked : void 0;
+  }
+  /**
+   * The style a block uses when it names none: Normal for paragraphs,
+   * Heading N for headings of level N, Code for code blocks (the built-in
+   * style whose own `block` matches).
+   */
+  defaultStyleFor(type, attrs = {}) {
+    if (type === "paragraph" && this.styles.get(NORMAL_STYLE_ID)) return NORMAL_STYLE_ID;
+    const candidates = this.list("paragraph").filter(
+      (style) => style.block && sameBlock(style.block, type, attrs)
+    );
+    return (candidates.find((s) => s.builtin) ?? candidates[0])?.id ?? null;
+  }
+  /** The style of a block: its `styleId` when known, otherwise the block's default style. */
+  styleOfBlock(type, attrs = {}) {
+    const id = attrs.styleId;
+    if (id && this.styles.get(id)?.kind === "paragraph") return id;
+    return this.defaultStyleFor(type, attrs);
+  }
+  getSnapshot = () => {
+    if (!this.snapshot) {
+      this.snapshot = Object.freeze({
+        styles: Object.freeze(this.list()),
+        defaults: this.defaults,
+        version: this.version
+      });
+    }
+    return this.snapshot;
+  };
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    listener(this.getSnapshot());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  toJSON() {
+    return { styles: clone(Array.from(this.styles.values())), defaults: clone(this.defaults) };
+  }
+  // -- Writing --------------------------------------------------------------
+  /** Adds or replaces a style. Throws on an invalid id. */
+  upsert(style) {
+    const stored = this.put(style);
+    this.changed();
+    return stored;
+  }
+  /** Merges `patch` into a style (formats are merged key by key). Returns `undefined` for unknown ids. */
+  update(id, patch) {
+    const current = this.styles.get(id);
+    if (!current) return void 0;
+    const next = {
+      ...current,
+      ...patch,
+      id,
+      paragraph: patch.paragraph ? { ...current.paragraph, ...patch.paragraph } : current.paragraph,
+      character: patch.character ? { ...current.character, ...patch.character } : current.character
+    };
+    return this.upsert(next);
+  }
+  /**
+   * Removes a style and returns it. Built-in styles cannot be removed. Styles
+   * based on it are rebased onto its own base, and `next`/`linked`
+   * references to it are dropped.
+   */
+  remove(id) {
+    const gone = this.styles.get(id);
+    if (!gone || gone.builtin) return void 0;
+    this.styles.delete(id);
+    this.styles.forEach((style, key) => {
+      let changed = style;
+      if (style.basedOn === id) {
+        changed = { ...changed, basedOn: gone.basedOn && gone.basedOn !== key ? gone.basedOn : null };
+      }
+      if (style.next === id) changed = { ...changed, next: null };
+      if (style.linked === id) changed = { ...changed, linked: null };
+      if (changed !== style) this.styles.set(key, changed);
+    });
+    this.changed();
+    return gone;
+  }
+  /** Replaces the document defaults. */
+  setDefaults(defaults) {
+    this.defaults = clone(defaults);
+    this.changed();
+  }
+  /** An unused id derived from a display name (`My Style` → `MyStyle`, then `MyStyle1`, …). */
+  newId(name) {
+    let base = name.replace(/[^A-Za-z0-9_-]+/g, "").replace(/^[^A-Za-z]+/, "").slice(0, 56);
+    if (!base) base = "Style";
+    if (!this.styles.has(base)) return base;
+    for (let i = 1; i < 1e5; i++) {
+      const id = `${base}${i}`;
+      if (!this.styles.has(id)) return id;
+    }
+    return `${base}${Date.now()}`;
+  }
+  // -- CSS --------------------------------------------------------------------
+  /** CSS declarations (`property: value`) of a resolved paragraph or character style. */
+  cssDeclarations(id) {
+    const style = this.styles.get(id);
+    if (style?.kind === "character") return characterCSS(this.resolveCharacterStyle(id));
+    const resolved = this.resolve(id);
+    return { ...paragraphCSS(resolved.paragraph), ...characterCSS(resolved.character) };
+  }
+  /**
+   * Declarations for previewing a style in a menu or gallery: font family,
+   * weight, style, color, decoration, case and letter spacing (no sizes,
+   * margins or borders).
+   */
+  previewDeclarations(id) {
+    return Object.fromEntries(
+      Object.entries(this.cssDeclarations(id)).filter(([property]) => PREVIEW_PROPERTIES.has(property))
+    );
+  }
+  /**
+   * A stylesheet for the styles: `[data-style="Id"]` rules for paragraph
+   * styles (plus the plain element of blocks that use their default style,
+   * e.g. `h2:not([data-style])`), `[data-char-style="Id"]` for character
+   * styles and the defaults on the scope element.
+   */
+  toCSS(options = {}) {
+    const scope = options.scope ?? ".ProseMirror";
+    const tagFor = options.tagFor ?? defaultTagFor;
+    const rules = [];
+    const rule = (selectors, declarations) => {
+      const body = Object.entries(declarations).map(([property, value]) => `${property}: ${value};`).join(" ");
+      if (body) rules.push(`${selectors.join(", ")} { ${body} }`);
+    };
+    rule([scope], {
+      ...paragraphCSS(this.defaults.paragraph ?? {}),
+      ...characterCSS(this.defaults.character ?? {})
+    });
+    this.list().forEach((style) => {
+      if (style.kind === "character") {
+        rule([`${scope} [data-char-style="${style.id}"]`], this.cssDeclarations(style.id));
+        return;
+      }
+      const selectors = [`${scope} [data-style="${style.id}"]`];
+      const block = this.resolve(style.id).block;
+      if (this.defaultStyleFor(block.type, block.attrs ?? {}) === style.id) {
+        const tag = tagFor(block);
+        if (tag) selectors.push(`${scope} ${tag}:not([data-style])`);
+      }
+      const resolved = this.resolve(style.id);
+      const own = {
+        ...paragraphCSS(withoutDefaults(resolved.paragraph, this.defaults.paragraph)),
+        ...characterCSS(withoutDefaults(resolved.character, this.defaults.character))
+      };
+      rule(selectors, own);
+    });
+    return rules.join("\n");
+  }
+  // -- Internals --------------------------------------------------------------
+  put(style) {
+    if (!isValidStyleId(style.id)) throw new Error(`Invalid style id: ${String(style.id)}`);
+    if (style.kind !== "paragraph" && style.kind !== "character") {
+      throw new Error(`Invalid style kind: ${String(style.kind)}`);
+    }
+    const stored = clone({ ...style, name: style.name || style.id });
+    this.styles.set(style.id, stored);
+    return stored;
+  }
+  changed() {
+    this.version++;
+    this.snapshot = null;
+    const snapshot = this.getSnapshot();
+    this.listeners.forEach((listener) => {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        console.error("[StyleRegistry] Error in listener:", err);
+      }
+    });
+  }
+};
+function withoutDefaults(format, defaults) {
+  if (!defaults) return format;
+  const out = {};
+  Object.entries(format).forEach(([key, value]) => {
+    if (defaults[key] !== value) out[key] = value;
+  });
+  return out;
+}
+function defaultTagFor(block) {
+  if (block.type === "paragraph") return "p";
+  if (block.type === "heading") {
+    const level = Number(block.attrs?.level);
+    return level >= 1 && level <= 6 ? `h${level}` : null;
+  }
+  if (block.type === "codeBlock") return "pre";
+  return null;
+}
+function safeCSSValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > 200 || UNSAFE_CSS.test(trimmed)) return void 0;
+  return trimmed;
+}
+function paragraphCSS(format) {
+  const out = {};
+  const set = (property, value) => {
+    const safe = safeCSSValue(value);
+    if (safe) out[property] = safe;
+  };
+  set("text-align", format.textAlign);
+  set("line-height", format.lineHeight);
+  set("margin-top", format.spaceBefore);
+  set("margin-bottom", format.spaceAfter);
+  set("margin-left", format.indentLeft);
+  set("margin-right", format.indentRight);
+  set("text-indent", format.indentFirstLine);
+  set("border-left", format.borderLeft);
+  set("padding-left", format.paddingLeft);
+  set("background-color", format.backgroundColor);
+  return out;
+}
+function characterCSS(format) {
+  const out = {};
+  const set = (property, value) => {
+    const safe = safeCSSValue(value);
+    if (safe) out[property] = safe;
+  };
+  set("font-family", format.fontFamily);
+  set("font-size", format.fontSize);
+  if (format.bold !== void 0) out["font-weight"] = format.bold ? "700" : "400";
+  if (format.italic !== void 0) out["font-style"] = format.italic ? "italic" : "normal";
+  const lines = [format.underline && "underline", format.strike && "line-through"].filter(Boolean);
+  if (format.underline !== void 0 || format.strike !== void 0) {
+    out["text-decoration-line"] = lines.length ? lines.join(" ") : "none";
+  }
+  set("color", format.color);
+  set("background-color", format.backgroundColor);
+  set("letter-spacing", format.letterSpacing);
+  set("text-transform", format.textTransform);
+  if (format.smallCaps !== void 0) out["font-variant-caps"] = format.smallCaps ? "small-caps" : "normal";
+  return out;
+}
+function createStyleRegistry(options = {}) {
+  return new StyleRegistry(options);
+}
+
+// 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 {
+  NORMAL_STYLE_ID,
+  isValidStyleId,
+  DEFAULT_STYLES,
+  StyleRegistry,
+  safeCSSValue,
+  createStyleRegistry,
+  ZipError,
+  DEFAULT_ZIP_MAX_ENTRIES,
+  DEFAULT_ZIP_MAX_TOTAL_SIZE,
+  zipCrc32,
+  isUnsafeZipPath,
+  ZipArchive,
+  readZip
+};
+//# sourceMappingURL=chunk-MR2764X2.js.map