@sametalmdr/word-editor 0.2.0-alpha → 0.3.0-alpha

package/dist/io/ooxml/zip-reject.js

@@ -1,106 +1,106 @@
-// The five zip-format features this reader refuses to guess about (§3.5,
-// ADR-0020 Karar 4). Each gets its OWN check and its OWN message — a single
-// "corrupt file" error would not tell a caller WHICH unsupported feature it
-// hit, and CLAUDE.md's own rule against guessing OOXML/format semantics
-// applies exactly here: ZIP64, an encrypted entry, a data-descriptor-only
-// entry, a multi-disk archive, or an unknown compression method could each
-// be handled in more than one plausible way, and a wrong guess corrupts a
-// document silently. Ported from scripts/opc-bytes.py's read_package() —
-// same five checks, same reasoning, not reinvented.
-//
-// Plain Error with a descriptive message, not a custom class — this matches
-// every other src/ file's error convention (grep confirms zero custom Error
-// subclasses anywhere in src/) and Python's own ImportRejected/OpcError,
-// which are also single classes distinguished by message, not a hierarchy.
-
-const ZIP64_SENTINEL = 0xffffffff;
-const FLAG_ENCRYPTED = 0x0001;
-const FLAG_DATA_DESCRIPTOR = 0x0008;
-const METHOD_STORE = 0;
-const METHOD_DEFLATE = 8;
-
-/**
- * A zip comment can follow the EOCD record, so the EOCD locator search
- * window is bounded but not zero-length. The ZIP64 EOCD locator (if present)
- * sits immediately before the ZIP64 EOCD record, itself immediately before
- * the classic EOCD — so "does a ZIP64 locator signature appear anywhere
- * before the classic EOCD we found" is the same check opc-bytes.py makes
- * (`data.rfind(ZIP64_EOCD_LOCATOR_SIG, 0, eocd_off) >= 0`).
- * @param {Uint8Array} bytes
- * @param {number} eocdOffset
- * @returns {void}
- */
-export function rejectZip64Locator(bytes, eocdOffset) {
-  const sig = [0x50, 0x4b, 0x06, 0x07]; // "PK\x06\x07"
-  for (let i = eocdOffset - 4; i >= 0; i--) {
-    if (bytes[i] === sig[0] && bytes[i + 1] === sig[1] && bytes[i + 2] === sig[2] && bytes[i + 3] === sig[3]) {
-      throw new Error(
-        "zip: ZIP64 end-of-central-directory locator found — refusing (this reader handles classic zip only)"
-      );
-    }
-  }
-}
-
-/**
- * @param {{diskWithCd: number, thisDisk: number, cdOffset: number, cdSize: number}} eocdFields
- * @returns {void}
- */
-export function rejectZip64EocdSentinel(eocdFields) {
-  if (eocdFields.cdOffset === ZIP64_SENTINEL || eocdFields.cdSize === ZIP64_SENTINEL) {
-    throw new Error("zip: ZIP64 sentinel (0xFFFFFFFF) in the end-of-central-directory record — refusing");
-  }
-  if (eocdFields.diskWithCd !== 0 || eocdFields.thisDisk !== 0) {
-    throw new Error(
-      `zip: multi-disk archive (thisDisk=${eocdFields.thisDisk}, diskWithCd=${eocdFields.diskWithCd}) — refusing`
-    );
-  }
-}
-
-/**
- * @param {string} name
- * @param {number} csize
- * @param {number} usize
- * @param {number} localOffset
- * @returns {void}
- */
-export function rejectEntryZip64Sentinel(name, csize, usize, localOffset) {
-  if (csize === ZIP64_SENTINEL || usize === ZIP64_SENTINEL || localOffset === ZIP64_SENTINEL) {
-    throw new Error(`zip: ${JSON.stringify(name)} has a ZIP64 sentinel (0xFFFFFFFF) in its central directory entry — refusing`);
-  }
-}
-
-/**
- * @param {string} name
- * @param {number} flags  the central directory entry's general-purpose bit flag
- * @returns {void}
- */
-export function rejectEntryEncrypted(name, flags) {
-  if ((flags & FLAG_ENCRYPTED) !== 0) {
-    throw new Error(`zip: ${JSON.stringify(name)} is encrypted — refusing`);
-  }
-}
-
-/**
- * @param {string} name
- * @param {number} flags
- * @returns {void}
- */
-export function rejectEntryDataDescriptor(name, flags) {
-  if ((flags & FLAG_DATA_DESCRIPTOR) !== 0) {
-    throw new Error(
-      `zip: ${JSON.stringify(name)} uses a data descriptor (general-purpose flag bit 3) — its sizes are ` +
-        "not in the local header, refusing rather than guessing"
-    );
-  }
-}
-
-/**
- * @param {string} name
- * @param {number} method
- * @returns {void}
- */
-export function rejectEntryUnknownMethod(name, method) {
-  if (method !== METHOD_STORE && method !== METHOD_DEFLATE) {
-    throw new Error(`zip: ${JSON.stringify(name)} uses compression method ${method} — refusing (store/deflate only)`);
-  }
-}
+// The five zip-format features this reader refuses to guess about (§3.5,
+// ADR-0020 Karar 4). Each gets its OWN check and its OWN message — a single
+// "corrupt file" error would not tell a caller WHICH unsupported feature it
+// hit, and CLAUDE.md's own rule against guessing OOXML/format semantics
+// applies exactly here: ZIP64, an encrypted entry, a data-descriptor-only
+// entry, a multi-disk archive, or an unknown compression method could each
+// be handled in more than one plausible way, and a wrong guess corrupts a
+// document silently. Ported from scripts/opc-bytes.py's read_package() —
+// same five checks, same reasoning, not reinvented.
+//
+// Plain Error with a descriptive message, not a custom class — this matches
+// every other src/ file's error convention (grep confirms zero custom Error
+// subclasses anywhere in src/) and Python's own ImportRejected/OpcError,
+// which are also single classes distinguished by message, not a hierarchy.
+
+const ZIP64_SENTINEL = 0xffffffff;
+const FLAG_ENCRYPTED = 0x0001;
+const FLAG_DATA_DESCRIPTOR = 0x0008;
+const METHOD_STORE = 0;
+const METHOD_DEFLATE = 8;
+
+/**
+ * A zip comment can follow the EOCD record, so the EOCD locator search
+ * window is bounded but not zero-length. The ZIP64 EOCD locator (if present)
+ * sits immediately before the ZIP64 EOCD record, itself immediately before
+ * the classic EOCD — so "does a ZIP64 locator signature appear anywhere
+ * before the classic EOCD we found" is the same check opc-bytes.py makes
+ * (`data.rfind(ZIP64_EOCD_LOCATOR_SIG, 0, eocd_off) >= 0`).
+ * @param {Uint8Array} bytes
+ * @param {number} eocdOffset
+ * @returns {void}
+ */
+export function rejectZip64Locator(bytes, eocdOffset) {
+  const sig = [0x50, 0x4b, 0x06, 0x07]; // "PK\x06\x07"
+  for (let i = eocdOffset - 4; i >= 0; i--) {
+    if (bytes[i] === sig[0] && bytes[i + 1] === sig[1] && bytes[i + 2] === sig[2] && bytes[i + 3] === sig[3]) {
+      throw new Error(
+        "zip: ZIP64 end-of-central-directory locator found — refusing (this reader handles classic zip only)"
+      );
+    }
+  }
+}
+
+/**
+ * @param {{diskWithCd: number, thisDisk: number, cdOffset: number, cdSize: number}} eocdFields
+ * @returns {void}
+ */
+export function rejectZip64EocdSentinel(eocdFields) {
+  if (eocdFields.cdOffset === ZIP64_SENTINEL || eocdFields.cdSize === ZIP64_SENTINEL) {
+    throw new Error("zip: ZIP64 sentinel (0xFFFFFFFF) in the end-of-central-directory record — refusing");
+  }
+  if (eocdFields.diskWithCd !== 0 || eocdFields.thisDisk !== 0) {
+    throw new Error(
+      `zip: multi-disk archive (thisDisk=${eocdFields.thisDisk}, diskWithCd=${eocdFields.diskWithCd}) — refusing`
+    );
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {number} csize
+ * @param {number} usize
+ * @param {number} localOffset
+ * @returns {void}
+ */
+export function rejectEntryZip64Sentinel(name, csize, usize, localOffset) {
+  if (csize === ZIP64_SENTINEL || usize === ZIP64_SENTINEL || localOffset === ZIP64_SENTINEL) {
+    throw new Error(`zip: ${JSON.stringify(name)} has a ZIP64 sentinel (0xFFFFFFFF) in its central directory entry — refusing`);
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {number} flags  the central directory entry's general-purpose bit flag
+ * @returns {void}
+ */
+export function rejectEntryEncrypted(name, flags) {
+  if ((flags & FLAG_ENCRYPTED) !== 0) {
+    throw new Error(`zip: ${JSON.stringify(name)} is encrypted — refusing`);
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {number} flags
+ * @returns {void}
+ */
+export function rejectEntryDataDescriptor(name, flags) {
+  if ((flags & FLAG_DATA_DESCRIPTOR) !== 0) {
+    throw new Error(
+      `zip: ${JSON.stringify(name)} uses a data descriptor (general-purpose flag bit 3) — its sizes are ` +
+        "not in the local header, refusing rather than guessing"
+    );
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {number} method
+ * @returns {void}
+ */
+export function rejectEntryUnknownMethod(name, method) {
+  if (method !== METHOD_STORE && method !== METHOD_DEFLATE) {
+    throw new Error(`zip: ${JSON.stringify(name)} uses compression method ${method} — refusing (store/deflate only)`);
+  }
+}

package/dist/measure/placement.js

@@ -1,83 +1,83 @@
-// A `PageMeasureReport`'s ACTIVE entry (ADR-0019 Karar 7), converted to
-// client-px placements a `WarningLayer` can paint — the measure-layer twin
-// of `overlay.js`'s `handlePlacements`/`guidePlacements`. Pure: page-pt
-// geometry in, client-px placements out. No src/, DOM, or history import.
-//
-// Only the ACTIVE box ever produces placements (§7's own two-tier design):
-// the passive tier is a status-line tally, never painted on the canvas.
-// `within-noise`/`fits` with no bleed and no out-of-page produce `null` too
-// — even the active box gets nothing to show when there is nothing to warn
-// about.
-
-import { pageToClientRect } from "../canvas/viewport.js";
-
-/**
- * @typedef {object} BadgePlacement
- * @property {number} left  client px, anchored at the box's own top-right corner
- * @property {number} top   client px
- * @property {string} text
- */
-
-/**
- * @typedef {object} WarningPlacements
- * @property {{left: number, top: number, width: number, height: number}} outline  the active box's own declared rect, client px
- * @property {BadgePlacement | null} overflowBadge
- * @property {BadgePlacement | null} outOfPageBadge
- * @property {{left: number, top: number, width: number, height: number}[]} bleedOutlines  one per neighbor the active box's content reaches into
- */
-
-/**
- * @param {import("./extent.js").OverflowVerdict} overflow
- * @returns {string}
- */
-function overflowLabel(overflow) {
-  const maxBy = Math.max(overflow.topBy, overflow.bottomBy, overflow.leftBy, overflow.rightBy);
-  return `+${Math.round(maxBy)}pt`;
-}
-
-/**
- * @param {import("./page-bounds.js").OutOfPageVerdict} outOfPage
- * @returns {string}
- */
-function outOfPageLabel(outOfPage) {
-  const maxBy = Math.max(outOfPage.leftBy, outOfPage.topBy, outOfPage.rightBy, outOfPage.bottomBy);
-  return `${Math.round(maxBy)}pt off-page`;
-}
-
-/**
- * @param {{left: number, top: number, width: number, height: number}} outline
- * @param {string} text
- * @returns {BadgePlacement}
- */
-function badgeAt(outline, text) {
-  return { left: outline.left + outline.width, top: outline.top, text };
-}
-
-/**
- * @param {import("./report.js").PageMeasureReport} report
- * @param {import("../canvas/viewport.js").PageRect} pageRect
- * @returns {WarningPlacements | null}
- */
-export function warningPlacements(report, pageRect) {
-  const active = report.active;
-  if (active === null) {
-    return null;
-  }
-
-  const hasOverflow = active.overflow.kind === "overflow";
-  const hasBleed = active.bleeds.length > 0;
-  const hasOutOfPage = active.outOfPage !== null;
-  if (!hasOverflow && !hasBleed && !hasOutOfPage) {
-    return null; // fits/within-noise, on-page, no bleed — the active box has nothing to show either
-  }
-
-  const outline = pageToClientRect(pageRect, active.declaredRect);
-  return {
-    outline,
-    overflowBadge: hasOverflow ? badgeAt(outline, overflowLabel(active.overflow)) : null,
-    outOfPageBadge: hasOutOfPage
-      ? badgeAt(outline, outOfPageLabel(/** @type {import("./page-bounds.js").OutOfPageVerdict} */ (active.outOfPage)))
-      : null,
-    bleedOutlines: active.bleeds.map((hit) => pageToClientRect(pageRect, hit.rect)),
-  };
-}
+// A `PageMeasureReport`'s ACTIVE entry (ADR-0019 Karar 7), converted to
+// client-px placements a `WarningLayer` can paint — the measure-layer twin
+// of `overlay.js`'s `handlePlacements`/`guidePlacements`. Pure: page-pt
+// geometry in, client-px placements out. No src/, DOM, or history import.
+//
+// Only the ACTIVE box ever produces placements (§7's own two-tier design):
+// the passive tier is a status-line tally, never painted on the canvas.
+// `within-noise`/`fits` with no bleed and no out-of-page produce `null` too
+// — even the active box gets nothing to show when there is nothing to warn
+// about.
+
+import { pageToClientRect } from "../canvas/viewport.js";
+
+/**
+ * @typedef {object} BadgePlacement
+ * @property {number} left  client px, anchored at the box's own top-right corner
+ * @property {number} top   client px
+ * @property {string} text
+ */
+
+/**
+ * @typedef {object} WarningPlacements
+ * @property {{left: number, top: number, width: number, height: number}} outline  the active box's own declared rect, client px
+ * @property {BadgePlacement | null} overflowBadge
+ * @property {BadgePlacement | null} outOfPageBadge
+ * @property {{left: number, top: number, width: number, height: number}[]} bleedOutlines  one per neighbor the active box's content reaches into
+ */
+
+/**
+ * @param {import("./extent.js").OverflowVerdict} overflow
+ * @returns {string}
+ */
+function overflowLabel(overflow) {
+  const maxBy = Math.max(overflow.topBy, overflow.bottomBy, overflow.leftBy, overflow.rightBy);
+  return `+${Math.round(maxBy)}pt`;
+}
+
+/**
+ * @param {import("./page-bounds.js").OutOfPageVerdict} outOfPage
+ * @returns {string}
+ */
+function outOfPageLabel(outOfPage) {
+  const maxBy = Math.max(outOfPage.leftBy, outOfPage.topBy, outOfPage.rightBy, outOfPage.bottomBy);
+  return `${Math.round(maxBy)}pt off-page`;
+}
+
+/**
+ * @param {{left: number, top: number, width: number, height: number}} outline
+ * @param {string} text
+ * @returns {BadgePlacement}
+ */
+function badgeAt(outline, text) {
+  return { left: outline.left + outline.width, top: outline.top, text };
+}
+
+/**
+ * @param {import("./report.js").PageMeasureReport} report
+ * @param {import("../canvas/viewport.js").PageRect} pageRect
+ * @returns {WarningPlacements | null}
+ */
+export function warningPlacements(report, pageRect) {
+  const active = report.active;
+  if (active === null) {
+    return null;
+  }
+
+  const hasOverflow = active.overflow.kind === "overflow";
+  const hasBleed = active.bleeds.length > 0;
+  const hasOutOfPage = active.outOfPage !== null;
+  if (!hasOverflow && !hasBleed && !hasOutOfPage) {
+    return null; // fits/within-noise, on-page, no bleed — the active box has nothing to show either
+  }
+
+  const outline = pageToClientRect(pageRect, active.declaredRect);
+  return {
+    outline,
+    overflowBadge: hasOverflow ? badgeAt(outline, overflowLabel(active.overflow)) : null,
+    outOfPageBadge: hasOutOfPage
+      ? badgeAt(outline, outOfPageLabel(/** @type {import("./page-bounds.js").OutOfPageVerdict} */ (active.outOfPage)))
+      : null,
+    bleedOutlines: active.bleeds.map((hit) => pageToClientRect(pageRect, hit.rect)),
+  };
+}

package/dist/measure/report.js

@@ -1,75 +1,75 @@
-// One page's worth of already-classified box results, reorganized into the
-// two tiers ADR-0019 Karar 7 decided on: an ACTIVE box (0 or 1, whichever
-// was just touched) and a PASSIVE tally of everything else. No src/, DOM, or
-// history import — this file makes no rendering decision, it only shapes
-// data a later warning layer reads.
-//
-// 🔴 TAŞMA (overflow/bleed) and SAYFA DIŞI (out-of-page) are counted
-// SEPARATELY, never folded into one number — ADR-0019 Karar 4: one is a
-// content problem ("bu kutuya fazla yazdın"), the other a placement problem
-// ("bu kutu sayfadan çıktı"), and a single combined count would not tell a
-// user which one to go fix.
-//
-// The active tier is 0..1 by CONSTRUCTION here, not by a rule this file
-// enforces: `activeId` names at most one entry, so `entries.find` can return
-// at most one result. A future multi-select active tier would be a
-// different function, not a relaxed version of this one.
-
-import { requireMeasureMetrics } from "./extent.js";
-
-/**
- * @typedef {object} BoxMeasureEntry
- * @property {import("../model/node.js").NodeId} id
- * @property {import("../canvas/geometry.js").Rect} declaredRect  the box's own declared rect — placement.js positions a badge/outline from this, not by looking the box up a second time
- * @property {import("./extent.js").OverflowVerdict} overflow
- * @property {import("../canvas/geometry.js").Rect | null} [overflowRect]  from extent.js's own `overflowRect` — placement.js draws the excess region from this when present
- * @property {import("./bleed.js").BleedHit[]} bleeds
- * @property {import("./page-bounds.js").OutOfPageVerdict | null} outOfPage
- * @property {boolean} [stale]  true when this entry is the last DOM-measured value shown during an open gesture, not a fresh read (ADR-0019 §2.2 rule 2) — a display concern only, this file's own bucketing logic never reads it
- */
-
-/**
- * @typedef {object} PageMeasureReport
- * @property {BoxMeasureEntry | null} active
- * @property {object} passive
- * @property {number} passive.overflowing  boxes whose OWN overflow.kind is "overflow" (never the active box)
- * @property {number} passive.bleeding  boxes whose OWN `bleeds` is non-empty — a SOURCE count, not a target count: one box bleeding into six neighbors is +1 here, not +6. Never the active box, and (as of the caller's own gating — see MEAS13) never a within-noise source either, matching Karar 4's "within-noise never warns" for the active tier
- * @property {number} passive.withinNoise  boxes whose OWN overflow.kind is "within-noise" (never the active box)
- * @property {number} passive.outOfPage  boxes with a non-null outOfPage verdict (never the active box)
- */
-
-/**
- * @param {BoxMeasureEntry[]} entries  every measured box on the page
- * @param {import("../model/node.js").NodeId | null} activeId  the box just touched, or null if none
- * @param {import("./extent.js").MeasureMetrics} metrics
- * @returns {PageMeasureReport}
- */
-export function pageReport(entries, activeId, metrics) {
-  requireMeasureMetrics(metrics);
-
-  const active = entries.find((entry) => entry.id === activeId) ?? null;
-
-  let overflowing = 0;
-  let bleeding = 0;
-  let withinNoise = 0;
-  let outOfPage = 0;
-
-  for (const entry of entries) {
-    if (entry.id === activeId) {
-      continue; // passive is "diğer her şey" (ADR-0019 Karar 7) — the active box is never double-counted
-    }
-    if (entry.overflow.kind === "overflow") {
-      overflowing += 1;
-    } else if (entry.overflow.kind === "within-noise") {
-      withinNoise += 1;
-    }
-    if (entry.bleeds.length > 0) {
-      bleeding += 1; // ONE increment per SOURCE box, regardless of how many neighbors its own bleeds[] names
-    }
-    if (entry.outOfPage !== null) {
-      outOfPage += 1;
-    }
-  }
-
-  return { active, passive: { overflowing, bleeding, withinNoise, outOfPage } };
-}
+// One page's worth of already-classified box results, reorganized into the
+// two tiers ADR-0019 Karar 7 decided on: an ACTIVE box (0 or 1, whichever
+// was just touched) and a PASSIVE tally of everything else. No src/, DOM, or
+// history import — this file makes no rendering decision, it only shapes
+// data a later warning layer reads.
+//
+// 🔴 TAŞMA (overflow/bleed) and SAYFA DIŞI (out-of-page) are counted
+// SEPARATELY, never folded into one number — ADR-0019 Karar 4: one is a
+// content problem ("bu kutuya fazla yazdın"), the other a placement problem
+// ("bu kutu sayfadan çıktı"), and a single combined count would not tell a
+// user which one to go fix.
+//
+// The active tier is 0..1 by CONSTRUCTION here, not by a rule this file
+// enforces: `activeId` names at most one entry, so `entries.find` can return
+// at most one result. A future multi-select active tier would be a
+// different function, not a relaxed version of this one.
+
+import { requireMeasureMetrics } from "./extent.js";
+
+/**
+ * @typedef {object} BoxMeasureEntry
+ * @property {import("../model/node.js").NodeId} id
+ * @property {import("../canvas/geometry.js").Rect} declaredRect  the box's own declared rect — placement.js positions a badge/outline from this, not by looking the box up a second time
+ * @property {import("./extent.js").OverflowVerdict} overflow
+ * @property {import("../canvas/geometry.js").Rect | null} [overflowRect]  from extent.js's own `overflowRect` — placement.js draws the excess region from this when present
+ * @property {import("./bleed.js").BleedHit[]} bleeds
+ * @property {import("./page-bounds.js").OutOfPageVerdict | null} outOfPage
+ * @property {boolean} [stale]  true when this entry is the last DOM-measured value shown during an open gesture, not a fresh read (ADR-0019 §2.2 rule 2) — a display concern only, this file's own bucketing logic never reads it
+ */
+
+/**
+ * @typedef {object} PageMeasureReport
+ * @property {BoxMeasureEntry | null} active
+ * @property {object} passive
+ * @property {number} passive.overflowing  boxes whose OWN overflow.kind is "overflow" (never the active box)
+ * @property {number} passive.bleeding  boxes whose OWN `bleeds` is non-empty — a SOURCE count, not a target count: one box bleeding into six neighbors is +1 here, not +6. Never the active box, and (as of the caller's own gating — see MEAS13) never a within-noise source either, matching Karar 4's "within-noise never warns" for the active tier
+ * @property {number} passive.withinNoise  boxes whose OWN overflow.kind is "within-noise" (never the active box)
+ * @property {number} passive.outOfPage  boxes with a non-null outOfPage verdict (never the active box)
+ */
+
+/**
+ * @param {BoxMeasureEntry[]} entries  every measured box on the page
+ * @param {import("../model/node.js").NodeId | null} activeId  the box just touched, or null if none
+ * @param {import("./extent.js").MeasureMetrics} metrics
+ * @returns {PageMeasureReport}
+ */
+export function pageReport(entries, activeId, metrics) {
+  requireMeasureMetrics(metrics);
+
+  const active = entries.find((entry) => entry.id === activeId) ?? null;
+
+  let overflowing = 0;
+  let bleeding = 0;
+  let withinNoise = 0;
+  let outOfPage = 0;
+
+  for (const entry of entries) {
+    if (entry.id === activeId) {
+      continue; // passive is "diğer her şey" (ADR-0019 Karar 7) — the active box is never double-counted
+    }
+    if (entry.overflow.kind === "overflow") {
+      overflowing += 1;
+    } else if (entry.overflow.kind === "within-noise") {
+      withinNoise += 1;
+    }
+    if (entry.bleeds.length > 0) {
+      bleeding += 1; // ONE increment per SOURCE box, regardless of how many neighbors its own bleeds[] names
+    }
+    if (entry.outOfPage !== null) {
+      outOfPage += 1;
+    }
+  }
+
+  return { active, passive: { overflowing, bleeding, withinNoise, outOfPage } };
+}