@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-JQZ3BXWY.js

@@ -0,0 +1,382 @@
+import {
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  MarkupCompatibility,
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/chart-values.ts
+var namespaces = ["http://schemas.openxmlformats.org/drawingml/2006/chart", "http://purl.oclc.org/ooxml/drawingml/chart"];
+var groups = ["areaChart", "area3DChart", "lineChart", "line3DChart", "stockChart", "radarChart", "scatterChart", "pieChart", "pie3DChart", "doughnutChart", "barChart", "bar3DChart", "ofPieChart", "surfaceChart", "surface3DChart", "bubbleChart"];
+var plotMetadata = ["layout", "catAx", "valAx", "dateAx", "serAx", "dTable", "spPr"];
+var roleNames = { tx: "label", cat: "category", val: "value", xVal: "x", yVal: "y", bubbleSize: "bubble" };
+function decodeChartContent(root, part, budget) {
+  const w = root.namespace, paths = /* @__PURE__ */ new Map(), children = /* @__PURE__ */ new Map();
+  const raw = (node, path) => {
+    budget.charge("work", path.length + 1);
+    budget.charge("retainedBytes", 64 + path.length * 8);
+    paths.set(node, path);
+    node.children.forEach((child, i) => raw(child, [...path, i]));
+  };
+  raw(root, []);
+  const view = new MarkupCompatibility(root, documentCompatibilityProfile, budget);
+  const effective = (content) => {
+    const result = [];
+    for (const item of content) {
+      budget.charge("work", 1);
+      if ("source" in item) {
+        children.set(item.source, effective(item.content));
+        result.push(item.source);
+      }
+    }
+    return result;
+  };
+  effective(view.content);
+  const kids = (node) => children.get(node) ?? [];
+  const named = (node, name) => kids(node).filter((n) => n.namespace === w && n.localName === name);
+  const attr = (node, name, namespace = "") => node.attributes.find((a) => a.namespace === namespace && a.localName === name)?.value ?? null;
+  const reserve = (node, strings = []) => {
+    budget.charge("work", 1 + strings.reduce((n, s) => n + (s?.length ?? 0), 0));
+    budget.charge("retainedBytes", 128 + (paths.get(node)?.length ?? 0) * 8 + strings.reduce((n, s) => n + (s?.length ?? 0) * 2, 0));
+    budget.charge("matches", 1);
+  };
+  const issue = (code, node, message) => {
+    reserve(node, [code, part, message]);
+    budget.charge("diagnosticBytes", code.length + message.length + part.length + 32);
+    return { code, part, path: paths.get(node), message };
+  };
+  const rootIssues = [];
+  const text = (node, issues) => {
+    if (node.namespace !== w || node.content.some((c) => c.kind !== "text" && c.kind !== "cdata")) {
+      issues.push(issue("opaque-value", node, "A stored value has unsupported content."));
+      return null;
+    }
+    reserve(node, [node.text]);
+    return node.text;
+  };
+  const values = (node, name, issues) => {
+    const result = kids(node).filter((n) => n.localName === name).map((n) => text(n, issues));
+    if (result.length > 1) issues.push(issue("duplicate-value", node, "A singleton value has repeated declarations."));
+    return result;
+  };
+  const unsigned = (value) => {
+    if (value === null || !value || [...value].some((c) => c < "0" || c > "9")) return false;
+    let i = 0;
+    while (i < value.length - 1 && value[i] === "0") i++;
+    const token = value.slice(i);
+    return token.length < 10 || token.length === 10 && token <= "4294967295";
+  };
+  const declarations = (node, name, issues) => {
+    const result = named(node, name).map((n) => {
+      const value = attr(n, "val");
+      reserve(n, [value]);
+      if (!unsigned(value)) issues.push(issue("invalid-index", n, "A stored index or count is missing or malformed."));
+      return value;
+    });
+    if (result.length > 1) issues.push(issue("duplicate-declaration", node, "A singleton declaration is repeated."));
+    return result;
+  };
+  const points = (node, parentIssues) => {
+    const seen = /* @__PURE__ */ new Set();
+    return named(node, "pt").map((n) => {
+      const issues = [], index = attr(n, "idx");
+      reserve(n, [index]);
+      if (!unsigned(index)) issues.push(issue("invalid-index", n, "A stored point index is missing or malformed."));
+      if (index !== null) {
+        let i = 0;
+        while (i < index.length - 1 && index[i] === "0") i++;
+        const key = index.slice(i);
+        if (seen.has(key)) parentIssues.push(issue("duplicate-point-index", n, "Stored point indices are repeated."));
+        seen.add(key);
+      }
+      const stored = values(n, "v", issues);
+      if (stored.length !== 1) issues.push(issue("point-value-cardinality", n, "A point does not contain exactly one admitted value."));
+      return { path: paths.get(n), index, values: stored, issues };
+    });
+  };
+  const cache = (node, kind, cached) => {
+    reserve(node);
+    const issues = [], counts = declarations(node, "ptCount", issues), formatCodes = values(node, "formatCode", issues);
+    const ordinary = kind === "multilevel-string" ? [] : points(node, issues);
+    const levels = kind === "multilevel-string" ? named(node, "lvl").map((n) => {
+      reserve(n);
+      return { path: paths.get(n), points: points(n, issues) };
+    }) : [];
+    const allowed = ["ptCount", "formatCode", kind === "multilevel-string" ? "lvl" : "pt"];
+    for (const child of kids(node)) if (child.namespace !== w || !allowed.includes(child.localName)) issues.push(issue("opaque-cache-child", child, "Unsupported cache content remains uninterpreted."));
+    return { kind, path: paths.get(node), cached, freshness: cached ? "unknown" : null, counts, formatCodes, points: ordinary, levels, issues };
+  };
+  const source = (node, role) => {
+    reserve(node);
+    const issues = [], name = node.localName;
+    const allowed = role === "label" ? ["v", "strRef"] : role === "category" ? ["strLit", "numLit", "strRef", "numRef", "multiLvlStrRef"] : ["numLit", "numRef"];
+    const supported = node.namespace === w && allowed.includes(name);
+    let kind = !supported ? "opaque" : ["strRef", "numRef", "multiLvlStrRef"].includes(name) ? "reference" : "literal";
+    const literals = name === "v" ? [text(node, issues)] : [], formulas = values(node, "f", issues), caches = [];
+    if (!supported) issues.push(issue("opaque-source", node, "This stored series source is outside the bounded native profile."));
+    else if (name === "numLit" || name === "strLit") caches.push(cache(node, name === "numLit" ? "numeric" : "string", false));
+    else if (kind === "reference") {
+      const expected = name === "numRef" ? "numCache" : name === "strRef" ? "strCache" : "multiLvlStrCache";
+      for (const child of kids(node)) {
+        if (child.namespace === w && child.localName === expected) caches.push(cache(child, name === "numRef" ? "numeric" : name === "strRef" ? "string" : "multilevel-string", true));
+        else if (!(child.namespace === w && child.localName === "f")) issues.push(issue("opaque-source-child", child, "Unsupported reference-source content remains uninterpreted."));
+      }
+      if (caches.length > 1) issues.push(issue("ambiguous-cache", node, "A reference source has multiple cache declarations."));
+    }
+    if (issues.some((i) => i.code === "opaque-value") && name === "v") kind = "opaque";
+    return { role, namespace: node.namespace, localName: name, path: paths.get(node), kind, literals, formulas, caches, issues };
+  };
+  const seriesList = [], plotGroups = [];
+  if (!namespaces.includes(w) || root.localName !== "chartSpace") rootIssues.push(issue("opaque-chart-root", root, "The definition root is outside the bounded standard chart profile."));
+  const charts = named(root, "chart"), areas = charts.length === 1 ? named(charts[0], "plotArea") : [];
+  if (charts.length !== 1 || areas.length !== 1) rootIssues.push(issue("chart-structure", root, "Exactly one native chart and plot area are required for decoding."));
+  if (namespaces.includes(w) && root.localName === "chartSpace" && areas.length === 1) {
+    for (const group of kids(areas[0])) {
+      if (group.namespace !== w || !groups.includes(group.localName)) {
+        if (group.namespace !== w || !plotMetadata.includes(group.localName)) rootIssues.push(issue("opaque-plot-child", group, "Unsupported plot content remains uninterpreted."));
+        continue;
+      }
+      reserve(group, [group.localName]);
+      const groupIndex = plotGroups.length;
+      plotGroups.push({ type: group.localName, path: paths.get(group) });
+      for (const s of named(group, "ser")) {
+        reserve(s);
+        const issues = [], sources = [];
+        for (const container of kids(s)) {
+          const role = Object.hasOwn(roleNames, container.localName) ? roleNames[container.localName] : void 0;
+          if (!role) continue;
+          if (container.namespace !== w) {
+            sources.push(source(container, role));
+            continue;
+          }
+          if (!kids(container).length) {
+            issues.push(issue("missing-source", container, "A series source declaration is empty."));
+            sources.push(source(container, role));
+          }
+          for (const child of kids(container)) sources.push(source(child, role));
+        }
+        const labels = sources.filter((s2) => s2.role === "label");
+        let name = null, provenance = "missing";
+        if (labels.length === 1) {
+          const label = labels[0];
+          if (label.kind === "literal" && label.localName === "v" && label.literals.length === 1 && label.literals[0] !== null) {
+            name = label.literals[0];
+            provenance = "literal";
+          } else if (label.kind === "reference" && label.localName === "strRef" && label.caches.length === 1 && label.caches[0].points.length === 1 && label.caches[0].points[0].index === "0" && label.caches[0].points[0].values.length === 1 && label.caches[0].points[0].values[0] !== null) {
+            name = label.caches[0].points[0].values[0];
+            provenance = "cached";
+          } else {
+            provenance = label.kind === "opaque" ? "opaque" : "ambiguous";
+            issues.push(issue("ambiguous-label", s, "The stored label does not admit the compact name projection."));
+          }
+        } else if (labels.length > 1) {
+          provenance = "ambiguous";
+          issues.push(issue("ambiguous-label", s, "Multiple label sources do not admit the compact name projection."));
+        }
+        const primary = sources.filter((source2) => source2.role === (["scatterChart", "bubbleChart"].includes(group.localName) ? "y" : "value"));
+        let cachedValues = [];
+        if (primary.length === 1 && primary[0].kind === "reference" && primary[0].caches.length === 1 && primary[0].caches[0].kind === "numeric") {
+          cachedValues = primary[0].caches[0].points.map((p) => {
+            if (p.values.length === 1) return p.values[0];
+            issues.push(issue("point-value-cardinality", s, "A primary cache point has an absent or ambiguous value."));
+            return null;
+          });
+        } else {
+          issues.push(issue(primary.length > 1 || primary.some((p) => p.caches.length > 1) ? "ambiguous-primary-cache" : "missing-primary-cache", s, "The primary source does not admit a unique numeric reference cache projection."));
+        }
+        seriesList.push({ group: groupIndex, path: paths.get(s), indices: declarations(s, "idx", issues), orders: declarations(s, "order", issues), name, label: { provenance }, cachedValues, sources, issues });
+      }
+    }
+  }
+  if (!plotGroups.length) rootIssues.push(issue("no-native-plot-group", root, "No admitted native plot group is available."));
+  const externalData = named(root, "externalData").map((n) => {
+    reserve(n);
+    const r = w === namespaces[1] ? "http://purl.oclc.org/ooxml/officeDocument/relationships" : "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    return { path: paths.get(n), relationshipId: attr(n, "id", r), autoUpdate: named(n, "autoUpdate").map((a) => {
+      const value = attr(a, "val");
+      reserve(a, [value]);
+      if (value === null) rootIssues.push(issue("opaque-value", a, "A stored auto-update scalar is missing or unsupported."));
+      return value;
+    }) };
+  });
+  const chartTypes = plotGroups.map((g) => g.type);
+  return { status: plotGroups.length ? "decoded" : "opaque", chartType: plotGroups.length === 1 ? plotGroups[0].type : null, chartTypes, plotGroups, series: seriesList, externalData, issues: rootIssues };
+}
+
+// packages/safe-bash-docx-engine/src/charts.ts
+var standardMime = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
+var extendedMime = "application/vnd.ms-office.chartex+xml";
+var definitionRelations = ["http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart", "http://purl.oclc.org/ooxml/officeDocument/relationships/chart", "http://schemas.microsoft.com/office/2014/relationships/chartEx"];
+var resourceRoles = {
+  workbook: { types: ["http://schemas.openxmlformats.org/officeDocument/2006/relationships/package", "http://purl.oclc.org/ooxml/officeDocument/relationships/package"], mimes: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.spreadsheetml.template", "application/vnd.ms-excel.sheet.macroenabled.12", "application/vnd.ms-excel.template.macroenabled.12", "application/vnd.ms-excel.sheet.binary.macroenabled.12"] },
+  style: { types: ["http://schemas.microsoft.com/office/2011/relationships/chartStyle"], mimes: ["application/vnd.ms-office.chartstyle+xml"] },
+  color: { types: ["http://schemas.microsoft.com/office/2011/relationships/chartColorStyle"], mimes: ["application/vnd.ms-office.chartcolorstyle+xml"] }
+};
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function chartDefinitionParts(graph, budget) {
+  const names = /* @__PURE__ */ new Set();
+  for (const part of graph.parts) {
+    budget.charge("work", 1);
+    if ([standardMime, extendedMime].includes(parseMediaType(part.content_type))) names.add(part.partname);
+  }
+  for (const owner of ["/", ...graph.parts.filter((p) => p.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((p) => p.partname)]) for (const edge of graph.relationships(owner)) {
+    budget.charge("work", 1);
+    if (!edge.is_external && definitionRelations.includes(edge.reltype)) names.add(edge.target_part.partname);
+  }
+  budget.check("matches", names.size);
+  budget.charge("retainedBytes", names.size * 96);
+  return [...names].sort(compare).map((name) => graph.getPart(name));
+}
+async function inspectDocumentCharts(input, options, context) {
+  const settings = archiveSettings(context), invocation = validateDocxInvocation({ operation: "charts.list", inputs: ["document"], options }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((limit) => [limit.name, limit.value])));
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected archive bytes.");
+  budget.check("compressedInput", input.length);
+  budget.charge("retainedBytes", input.length);
+  budget.charge("work", input.length);
+  const owned = new Uint8Array(input);
+  const archive = await readDocumentArchive(owned, { ...settings, budget }), graph = archive.package;
+  const descriptors = /* @__PURE__ */ new Map(), roots = /* @__PURE__ */ new Map(), items = [], warnings = [];
+  const hash = async (bytes) => {
+    budget.charge("work", bytes.length);
+    budget.charge("retainedBytes", bytes.length + 128);
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)));
+    budget.check("work", 0);
+    return [...digest].map((b) => b.toString(16).padStart(2, "0")).join("");
+  };
+  const sourceSha256 = await hash(owned);
+  const descriptor = async (part) => {
+    const existing = descriptors.get(part.partname);
+    if (existing) return existing;
+    budget.charge("retainedBytes", 256 + (part.partname.length + part.content_type.length) * 2);
+    const record = { name: part.partname, contentType: part.content_type, bytes: part.bytes.length, sha256: await hash(part.bytes) };
+    descriptors.set(part.partname, record);
+    return record;
+  };
+  const root = (part) => {
+    let parsed = roots.get(part.partname);
+    if (!parsed) {
+      parsed = parseDocumentXml(part.bytes, {}, budget).root;
+      roots.set(part.partname, parsed);
+    }
+    return parsed;
+  };
+  const reference = (owner, edge) => {
+    budget.charge("retainedBytes", 128 + (owner.length + edge.rId.length + edge.reltype.length + edge.target_ref.length) * 2);
+    return { owner, id: edge.rId, type: edge.reltype, target: edge.target_ref, external: edge.is_external };
+  };
+  const allEdges = [];
+  for (const owner of ["/", ...graph.parts.filter((p) => p.content_type.toLowerCase() !== "application/vnd.openxmlformats-package.relationships+xml").map((p) => p.partname)]) for (const edge of graph.relationships(owner)) {
+    budget.charge("work", 1);
+    budget.charge("retainedBytes", 32);
+    allEdges.push({ owner, edge });
+  }
+  for (const part of chartDefinitionParts(graph, budget)) {
+    await budget.checkpoint();
+    const definition = await descriptor(part), parsed = root(part), decoded = decodeChartContent(parsed, part.partname, budget);
+    let status = decoded.status;
+    const issues = [...decoded.issues];
+    const issue = (code, path, message) => {
+      budget.charge("diagnosticBytes", code.length + message.length + part.partname.length + 32);
+      budget.charge("retainedBytes", 128 + (code.length + message.length + part.partname.length) * 2 + path.length * 8);
+      return { code, part: part.partname, path, message };
+    };
+    if (parseMediaType(part.content_type) !== standardMime) {
+      status = "opaque";
+      issues.push(issue("opaque-chart-type", [], "The declared resource type is outside the bounded standard chart profile."));
+    }
+    const outgoing = graph.relationships(part.partname);
+    const binding = async (role, id, path) => {
+      let state = "internal", edge, target = null;
+      const bindingIssues = [];
+      if (!id) state = "missing-id";
+      else {
+        edge = outgoing.find((e) => e.rId === id);
+        if (!edge) state = "missing-relationship";
+        else if (!resourceRoles[role].types.includes(edge.reltype)) state = "wrong-relationship-type";
+        else if (edge.is_external) state = "external";
+        else {
+          const targetPart = edge.target_part;
+          target = await descriptor(targetPart);
+          if (!resourceRoles[role].mimes.includes(parseMediaType(targetPart.content_type))) state = "wrong-resource-type";
+          else if (role !== "workbook") {
+            const metadata = root(targetPart);
+            if (metadata.namespace !== "http://schemas.microsoft.com/office/drawing/2012/chartStyle" || metadata.localName !== (role === "style" ? "chartStyle" : "colorStyle")) state = "opaque";
+          }
+        }
+      }
+      if (edge && !edge.is_external && !target) target = await descriptor(edge.target_part);
+      if (state !== "internal") bindingIssues.push(issue("chart-binding-" + state, path, "The stored resource binding is external, unresolved or outside its declared inert resource role."));
+      budget.charge("retainedBytes", 160 + path.length * 8);
+      return { role, relationshipId: id, reference: edge ? reference(part.partname, edge) : null, status: state, target, issues: bindingIssues };
+    };
+    const externalData = [];
+    for (const data2 of decoded.externalData) {
+      externalData.push({ ...data2, binding: await binding("workbook", data2.relationshipId, data2.path) });
+    }
+    const resources = [];
+    for (const edge of outgoing) {
+      for (const role of ["workbook", "style", "color"]) if (resourceRoles[role].types.includes(edge.reltype)) resources.push(await binding(role, edge.rId, []));
+    }
+    const workbookParts = [...new Set([...externalData.map((d) => d.binding), ...resources].filter((b) => b.role === "workbook" && b.status === "internal" && b.target).map((b) => b.target.name))].sort(compare);
+    const visited = /* @__PURE__ */ new Set(), pending = [part], graphParts = [];
+    while (pending.length) {
+      await budget.checkpoint(1);
+      const next = pending.pop();
+      if (visited.has(next.partname)) continue;
+      visited.add(next.partname);
+      budget.charge("retainedBytes", 96);
+      graphParts.push(await descriptor(next));
+      for (const edge of graph.relationships(next.partname)) {
+        budget.charge("work", 1);
+        if (!edge.is_external && !visited.has(edge.target_part.partname)) {
+          budget.charge("retainedBytes", 16);
+          pending.push(edge.target_part);
+        }
+      }
+    }
+    graphParts.sort((a, b) => compare(a.name, b.name));
+    const references = [];
+    for (const record of allEdges) {
+      budget.charge("work", 1);
+      if (visited.has(record.owner) || !record.edge.is_external && record.edge.target_part.partname === part.partname) references.push(reference(record.owner, record.edge));
+    }
+    references.sort((a, b) => compare(a.owner, b.owner) || compare(a.id, b.id));
+    const value = { version: 1, sourceSha256, generation: 0, part: part.partname, story: part.partname, path: [], range: null };
+    const location = { kind: "part", value, token: encodeGeneratedLocation(value), positions: {} };
+    budget.charge("matches", 1);
+    budget.charge("retainedBytes", 512 + location.token.length * 2);
+    const details = { kind: "charts", definition, root: { namespace: parsed.namespace, localName: parsed.localName }, status, chartType: status === "decoded" ? decoded.chartType : null, chartTypes: status === "decoded" ? decoded.chartTypes : [], plotGroups: status === "decoded" ? decoded.plotGroups : [], series: status === "decoded" ? decoded.series : [], externalData, workbookParts, resources, graphParts, issues };
+    items.push({ kind: "charts", location, name: part.partname, properties: [], references, support: status === "decoded" ? "read" : "preserve", details });
+  }
+  if (items.some((item) => item.support === "preserve" || item.details.issues.length || item.details.series.some((s) => s.issues.length || s.sources.some((source) => source.issues.length)))) warnings.push({ code: "partial-chart-inventory", message: "Some chart semantics are opaque, malformed or ambiguous; cached data is stored metadata with unknown freshness." });
+  const data = { items, warnings };
+  const size = measurePackageResourceSerialization({ version: 1, operation: "charts.list", ok: true, data, warnings, errors: [], affected: 0, locations: items.map((item) => item.location) }, budget);
+  budget.charge("retainedBytes", size);
+  return data;
+}
+
+export {
+  decodeChartContent,
+  chartDefinitionParts,
+  inspectDocumentCharts
+};

package/dist/safe-bash/command-chunks/{chunk-7DLR4HCC.js → chunk-JWSOFSGI.js}

@@ -1,8 +1,8 @@
 import {
-  he
-} from "./chunk-TUWGIF22.js";
+  g
+} from "./chunk-Z7ESJVFP.js";
 
-// packages/safe-bash-command-ssconvert/dist/chunks/chunk-VXLP6LZ6.js
+// packages/safe-bash-command-ssconvert/dist/chunks/chunk-V6HKHYMR.js
 import { createEngine as He } from "../../spreadsheet-engine/index.js";
 import { SsconvertError as W } from "../../spreadsheet-engine/contracts.js";
 import { SsconvertError as le } from "../../spreadsheet-engine/contracts.js";
@@ -30,7 +30,7 @@ var X = { id: "Gnumeric_applix", services: [{ id: "applix", direction: "read", r
 var B = { id: "Gnumeric_dif", services: [{ id: "dif", direction: "read", read: async (e, t) => (await import("./dif-BXKPQOCO-4KB3RC6G.js")).readDif(e, t), description: "Data Interchange Format (*.dif)", extensions: ["dif"], probePriority: 1 }, { id: "dif", direction: "write", write: async (e, t, n) => (await import("./dif-BXKPQOCO-4KB3RC6G.js")).writeDif(e, t, n), description: "Data Interchange Format (*.dif)", extensions: ["dif"], formatLevel: "manual_remember", saveScope: "sheet", selectionSource: "view" }], source: "plugins/dif/plugin.xml.in" };
 var Fe = ["xor", "rc4", ...[false, true].flatMap((e) => [40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128].map((t) => `rc4-cryptoapi-${t}${e ? "-properties" : ""}`))];
 var V = ["xor"];
-var M = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "excel", direction: "read", read: async (...e) => (await import("./biff-AU4VGVMD-6EQ64QPG.js")).readBiff(...e), probeContent: async (...e) => (await import("./biff-AU4VGVMD-6EQ64QPG.js")).probeBiff(...e), description: "MS Excel\u2122 (*.xls)", extensions: ["xls", "xlw", "xlt"], mimeTypes: ["application/vnd.ms-excel", "application/excel", "application/msexcel", "application/x-excel", "application/x-ms-excel", "application/x-msexcel", "application/x-xls", "application/xls", "application/x-dos_ms_excel", "zz-application/zz-winassoc-xls"], probePriority: 100, contentProbe: true }, { id: "excel_biff8", write: async (...e) => (await import("./biff-AU4VGVMD-6EQ64QPG.js")).createBiffWriter(8)(...e), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: Fe } }, direction: "write", description: "MS Excel\u2122 97/2000/XP", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto", defaultSaverPriority: 1 }, { id: "excel_biff7", write: async (...e) => (await import("./biff-AU4VGVMD-6EQ64QPG.js")).createBiffWriter(7)(...e), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: V } }, direction: "write", description: "MS Excel\u2122 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_dsf", write: async (...e) => (await import("./biff-AU4VGVMD-6EQ64QPG.js")).createBiffWriter("dsf")(...e), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: V } }, direction: "write", description: "MS Excel\u2122 97/2000/XP & 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_enc", direction: "read", read: async (...e) => (await import("./biff-AU4VGVMD-6EQ64QPG.js")).readBiff(...e), description: "MS Excel\u2122 (*.xls) requiring encoding specification", extensions: [], probePriority: 200, encodingDependent: true }] };
+var M = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "excel", direction: "read", read: async (...e) => (await import("./biff-YBHP7ZES-M7TU7NA5.js")).readBiff(...e), probeContent: async (...e) => (await import("./biff-YBHP7ZES-M7TU7NA5.js")).probeBiff(...e), description: "MS Excel\u2122 (*.xls)", extensions: ["xls", "xlw", "xlt"], mimeTypes: ["application/vnd.ms-excel", "application/excel", "application/msexcel", "application/x-excel", "application/x-ms-excel", "application/x-msexcel", "application/x-xls", "application/xls", "application/x-dos_ms_excel", "zz-application/zz-winassoc-xls"], probePriority: 100, contentProbe: true }, { id: "excel_biff8", write: async (...e) => (await import("./biff-YBHP7ZES-M7TU7NA5.js")).createBiffWriter(8)(...e), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: Fe } }, direction: "write", description: "MS Excel\u2122 97/2000/XP", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto", defaultSaverPriority: 1 }, { id: "excel_biff7", write: async (...e) => (await import("./biff-YBHP7ZES-M7TU7NA5.js")).createBiffWriter(7)(...e), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: V } }, direction: "write", description: "MS Excel\u2122 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_dsf", write: async (...e) => (await import("./biff-YBHP7ZES-M7TU7NA5.js")).createBiffWriter("dsf")(...e), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: V } }, direction: "write", description: "MS Excel\u2122 97/2000/XP & 5.0/95", extensions: ["xls"], mimeTypes: ["application/vnd.ms-excel"], formatLevel: "auto" }, { id: "excel_enc", direction: "read", read: async (...e) => (await import("./biff-YBHP7ZES-M7TU7NA5.js")).readBiff(...e), description: "MS Excel\u2122 (*.xls) requiring encoding specification", extensions: [], probePriority: 200, encodingDependent: true }] };
 var H = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "xlsx", direction: "read", probeContent: async (e, t) => (await import("./xlsx-RE54MFCS-RECJEVTB.js")).probeXlsx(e, t), read: async (e, t) => (await import("./xlsx-RE54MFCS-RECJEVTB.js")).readXlsx(e, t), description: "ECMA 376 / Office Open XML [MS Excel\u2122 2007/2010] (*.xlsx)", extensions: ["xlsx", "xltx", "xlsb", "xlsm", "xltm"], mimeTypes: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"], probePriority: 100, contentProbe: true }, { id: "xlsx", direction: "write", write: async (e, t, n) => (await import("./xlsx-RE54MFCS-RECJEVTB.js")).createXlsxWriter("2006")(e, t, n), description: "ECMA 376 1st edition (2006); [MS Excel\u2122 2007]", extensions: ["xlsx"], mimeTypes: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"], formatLevel: "auto" }, { id: "xlsx2", direction: "write", write: async (e, t, n) => (await import("./xlsx-RE54MFCS-RECJEVTB.js")).createXlsxWriter("2008")(e, t, n), description: "ISO/IEC 29500:2008 & ECMA 376 2nd edition (2008); [MS Excel\u2122 2010]", extensions: ["xlsx"], mimeTypes: ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"], formatLevel: "auto" }] };
 var G = { id: "Gnumeric_Excel", source: "plugins/excel/plugin.xml.in", services: [{ id: "excel_xml", direction: "read", read: async (e, t) => (await import("./spreadsheetml-FUAFHANW-NHCLA747.js")).readSpreadsheetML(e, t), probeContent: async (...e) => (await import("./spreadsheetml-FUAFHANW-NHCLA747.js")).probeSpreadsheetML(...e), description: "MS Excel\u2122 2003 SpreadsheetML", extensions: ["xml"], probePriority: 1, contentProbe: true }] };
 var $ = { ...M, services: [...M.services.slice(0, -1), ...G.services, ...H.services, M.services.at(-1)] };
@@ -43,9 +43,9 @@ var J = { id: "Gnumeric_lpsolve", services: [{ id: "lpsolve", direction: "write"
 var ee = { id: "Gnumeric_mps", services: [{ id: "mps", direction: "read", read: async (e, t) => (await import("./mps-6LOYNSEU-JHPKED6S.js")).readMps(e, t), description: "Linear and integer program (*.mps) file format", extensions: ["mps"], mimeTypes: ["application/x-mps"], probePriority: 1 }], source: "plugins/mps/plugin.xml.in" };
 var te = { id: "Gnumeric_oleo", services: [{ id: "oleo", direction: "read", read: async (e, t) => (await import("./oleo-YLVM3IBC-WE37C2QO.js")).readOleo(e, t), description: "GNU Oleo (*.oleo)", extensions: ["oleo"], mimeTypes: ["application/x-oleo"], probePriority: 100 }], source: "plugins/oleo/plugin.xml.in" };
 var re = ["odf12-aes128-cbc", "odf12-aes192-cbc", "odf12-aes256-cbc", "odf12-blowfish-cfb8", "odf12-blowfish-cfb64", "libreoffice-aes256-gcm"];
-var R = { id: "Gnumeric_OpenCalc", services: [{ id: "openoffice", direction: "read", read: async (e, t) => (await import("./odf-UKSXPNOZ-NCL5P7YL.js")).readOdf(e, t), probeContent: async (...e) => (await import("./odf-UKSXPNOZ-NCL5P7YL.js")).probeOdf(...e), description: "Open Document Format (*.sxc, *.ods)", extensions: ["ods", "ots", "sxc", "stc"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet", "application/vnd.oasis.opendocument.spreadsheet-template", "application/vnd.sun.xml.calc", "application/vnd.sun.xml.calc.template"], probePriority: 1, contentProbe: true }, { id: "openoffice", direction: "write", write: async (e, t, n) => (await import("./odf-UKSXPNOZ-NCL5P7YL.js")).createOdfWriter("strict")(e, t, n), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: re } }, description: "ODF 1.2 strict conformance (*.ods)", extensions: ["ods"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet"], formatLevel: "auto" }, { id: "odf", direction: "write", write: async (e, t, n) => (await import("./odf-UKSXPNOZ-NCL5P7YL.js")).createOdfWriter("extended")(e, t, n), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: re } }, description: "ODF 1.2 extended conformance (*.ods)", extensions: ["ods"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet"], formatLevel: "auto" }], source: "plugins/openoffice/plugin.xml.in" };
+var R = { id: "Gnumeric_OpenCalc", services: [{ id: "openoffice", direction: "read", read: async (e, t) => (await import("./odf-UKSXPNOZ-BV2LCKTB.js")).readOdf(e, t), probeContent: async (...e) => (await import("./odf-UKSXPNOZ-BV2LCKTB.js")).probeOdf(...e), description: "Open Document Format (*.sxc, *.ods)", extensions: ["ods", "ots", "sxc", "stc"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet", "application/vnd.oasis.opendocument.spreadsheet-template", "application/vnd.sun.xml.calc", "application/vnd.sun.xml.calc.template"], probePriority: 1, contentProbe: true }, { id: "openoffice", direction: "write", write: async (e, t, n) => (await import("./odf-UKSXPNOZ-BV2LCKTB.js")).createOdfWriter("strict")(e, t, n), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: re } }, description: "ODF 1.2 strict conformance (*.ods)", extensions: ["ods"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet"], formatLevel: "auto" }, { id: "odf", direction: "write", write: async (e, t, n) => (await import("./odf-UKSXPNOZ-BV2LCKTB.js")).createOdfWriter("extended")(e, t, n), labelRanges: true, exportOptionRules: { encryption: { kind: "enum", values: re } }, description: "ODF 1.2 extended conformance (*.ods)", extensions: ["ods"], mimeTypes: ["application/vnd.oasis.opendocument.spreadsheet"], formatLevel: "auto" }], source: "plugins/openoffice/plugin.xml.in" };
 var ie = { id: "Gnumeric_paradox", services: [{ id: "paradox", direction: "read", read: async (e, t) => (await import("./paradox-ZWWXYY4J-JYOSWSBL.js")).readParadox(e, t), description: "Paradox database or primary index file (*.db, *.px)", extensions: ["db", "px"], probePriority: 100 }, { id: "paradox", direction: "write", write: async (e, t, n) => (await import("./paradox-ZWWXYY4J-JYOSWSBL.js")).writeParadox(e, t, n), exportOptionRules: { encryption: { kind: "enum", values: ["paradox"] } }, description: "Paradox database (*.db)", extensions: ["db"] }], source: "plugins/paradox/plugin.xml.in" };
-var oe = { id: "Gnumeric_pdf", source: "src/print-info.c:1074", services: [{ id: "pdf_assistant", direction: "write", description: "PDF export", extensions: ["pdf"], sheetSelection: true, honorsExportRange: false, write: async (...e) => (await import("./pdf-M2GFAR2A-FCJMJCAP.js")).writePdf(...e), exportOptions: async (...e) => (await import("./pdf-M2GFAR2A-FCJMJCAP.js")).pdfExportOptions(...e), exportOptionRules: { object: { kind: "string" }, paper: { kind: "string" } } }] };
+var oe = { id: "Gnumeric_pdf", source: "src/print-info.c:1074", services: [{ id: "pdf_assistant", direction: "write", description: "PDF export", extensions: ["pdf"], sheetSelection: true, honorsExportRange: false, write: async (...e) => (await import("./pdf-22JDKKAR-UDWNSWYB.js")).writePdf(...e), exportOptions: async (...e) => (await import("./pdf-22JDKKAR-UDWNSWYB.js")).pdfExportOptions(...e), exportOptionRules: { object: { kind: "string" }, paper: { kind: "string" } } }] };
 var ne = { id: "Gnumeric_plan_perfect", services: [{ id: "pln", direction: "read", probeContent: async (e, t) => (await import("./pln-DFS7VLVS-JATX6FS7.js")).probePln(e, t), read: async (e, t) => (await import("./pln-DFS7VLVS-JATX6FS7.js")).readPln(e, t), description: "Plan Perfect Format (PLN) import", extensions: ["pln"], mimeTypes: ["application/x-planperfect"], probePriority: 1, contentProbe: true }], source: "plugins/plan-perfect/plugin.xml.in" };
 var se = { id: "Gnumeric_psiconv", services: [{ id: "psiconv", direction: "read", probeContent: async (e, t) => (await import("./psion-YBI6JEQI-6OMC2PGC.js")).probePsion(e, t), read: async (e, t) => (await import("./psion-YBI6JEQI-6OMC2PGC.js")).readPsion(e, t), description: "Psion (*.psisheet)", extensions: ["psisheet"], probePriority: 100, contentProbe: true }], source: "plugins/psiconv/plugin.xml.in" };
 var ae = { id: "Gnumeric_QPro", services: [{ id: "qpro", direction: "read", probeContent: async (e, t) => (await import("./qpro-WLWWL7C3-XZ5DBS44.js")).probeQpro(e, t), read: async (e, t) => (await import("./qpro-WLWWL7C3-XZ5DBS44.js")).readQpro(e, t), description: "Quattro Pro (*.wb1, *.wb2, *.wb3)", extensions: ["wb1", "wb2", "wb3"], mimeTypes: ["application/x-quattropro", "application/x-quattro-pro"], probePriority: 100, contentProbe: true }], source: "plugins/qpro/plugin.xml.in" };
@@ -290,12 +290,12 @@ async function xe(e, t, n) {
     }
     if (f++, y = Math.max(y, f + (l(s) ? 1 : 0)), s < r.length && l(s) && (s += l(s), p)) for (; s < r.length && l(s); ) s++;
   }
-  let v = Math.min(C.rows, u + (f > 0 ? 1 : 0)), g = { ...Oe };
-  for (; g.rows < v && g.rows < C.rows; ) g.rows *= 2;
-  for (; g.columns < y && g.columns < C.columns; ) g.columns *= 2;
+  let v = Math.min(C.rows, u + (f > 0 ? 1 : 0)), g2 = { ...Oe };
+  for (; g2.rows < v && g2.rows < C.rows; ) g2.rows *= 2;
+  for (; g2.columns < y && g2.columns < C.columns; ) g2.columns *= 2;
   let b = y > C.columns;
   h && await t.diagnostic?.({ code: "text-rows-exceeded", severity: "warning", message: "There are more rows of data than there is room for in the sheet.  Extra rows will be ignored." }), b && await t.diagnostic?.({ code: "text-cols-exceeded", severity: "warning", message: "There are more columns of data than there is room for in the sheet.  Extra columns will be ignored." }), (h || b) && await t.diagnostic?.({ code: "text-dropped", severity: "warning", message: "Some data did not fit on the sheet and was dropped." }), t.signal.throwIfAborted();
-  let S = { ...d, sheets: [{ ...d.sheets[0], size: g }] }, P = a.map((w) => {
+  let S = { ...d, sheets: [{ ...d.sheets[0], size: g2 }] }, P = a.map((w) => {
     if (t.signal.throwIfAborted(), w.value.kind !== "string") return w;
     let T = w.value.value;
     if (T.startsWith("=") && T.length > 1) {
@@ -312,7 +312,7 @@ async function xe(e, t, n) {
   }), E = { ...S, sheets: [{ ...S.sheets[0], cells: de(P, S, t, v) }] };
   return P.some((w) => w.formula) ? ke(E, t) : E;
 }
-async function he2(e, t) {
+async function he(e, t) {
   throw t.signal.throwIfAborted(), new W("io", "E This importer can only be used with a GUI.");
 }
 function Xe(e, t, n, r) {
@@ -373,13 +373,13 @@ async function ye(e, t) {
     if (!f) throw new _("invalid-request", `ssconvert: Unknown sheet "${u}"`);
     let y = c?.range && Ne(c.range, n, u);
     if (c?.range && !y) continue;
-    let h = 0, v = 0, g = /* @__PURE__ */ new Map();
-    for (let b of f.cells) a(), g.set(`${b.row}:${b.column}`, b), (b.cachedResult ?? b.value).kind !== "blank" && (h = Math.max(h, b.row), v = Math.max(v, b.column));
+    let h = 0, v = 0, g2 = /* @__PURE__ */ new Map();
+    for (let b of f.cells) a(), g2.set(`${b.row}:${b.column}`, b), (b.cachedResult ?? b.value).kind !== "blank" && (h = Math.max(h, b.row), v = Math.max(v, b.column));
     h = y?.endRow ?? h, v = y?.endColumn ?? v;
     for (let b = y?.startRow ?? 0; b <= h; b++) {
       for (let S = y?.startColumn ?? 0; S <= v; S++) {
         a(), S !== (y?.startColumn ?? 0) && o(t.separator);
-        let P = g.get(`${b}:${S}`), E = P?.cachedResult ?? P?.value;
+        let P = g2.get(`${b}:${S}`), E = P?.cachedResult ?? P?.value;
         if (E?.kind === "byte-string") {
           let w = Xe(ze(E.value, a, i.limits.outputBytes), t, x.limits.outputBytes - m, a);
           m += w.length, l.push(w);
@@ -392,12 +392,12 @@ async function ye(e, t) {
     let u = [], f = 0;
     for (let v of l) {
       a();
-      let g = typeof v == "string" ? I(v, "UTF-8", false, r) : v;
-      if (g.length > i.limits.outputBytes - f) throw new _("resource-limit", "ssconvert output bytes limit exceeded");
-      f += g.length, u.push(g);
+      let g2 = typeof v == "string" ? I(v, "UTF-8", false, r) : v;
+      if (g2.length > i.limits.outputBytes - f) throw new _("resource-limit", "ssconvert output bytes limit exceeded");
+      f += g2.length, u.push(g2);
     }
     let y = new Uint8Array(f), h = 0;
-    for (let v of u) for (let g of v) a(), y[h++] = g;
+    for (let v of u) for (let g2 of v) a(), y[h++] = g2;
     return y;
   }
   let s = l.join("");
@@ -445,10 +445,10 @@ var we = async (...e) => {
 };
 var ve = async (...e) => ye(e, { separator: ",", quote: '"', eol: `
 `, mode: "auto", whitespace: true, format: "automatic", charset: "UTF-8", transliterate: false });
-var q = { id: "Gnumeric_stf", source: "src/stf.c", services: [{ id: "stf_csvtab", direction: "read", description: "Comma or tab separated values (CSV/TSV)", extensions: ["csv", "tsv", "txt"], mimeTypes: ["application/tab-separated-values", "text/comma-separated-values", "text/csv", "text/x-csv", "text/spreadsheet", "text/tab-separated-values"], probePriority: 0, contentProbe: true, encodingDependent: true, probeName: N, probeContent: fe, read: xe }, { id: "stf_assistant", direction: "read", description: "Text import (configurable)", extensions: [], mimeTypes: ["text/plain", "text/csv", "text/x-csv", "text/comma-separated-values", "text/tab-separated-values"], probePriority: 0, encodingDependent: true, interactiveOnly: true, read: he2 }, { id: "stf_assistant", direction: "write", description: "Text (configurable)", extensions: ["txt"], byteStrings: "utf8-text", sheetSelection: true, honorsExportRange: true, write: we, exportOptionRules: { eol: { kind: "enum", values: ["unix", "mac", "windows"], asciiCaseInsensitive: true, error: "eol must be one of unix, mac, and windows" }, charset: { kind: "string" }, locale: { kind: "string" }, quote: { kind: "string" }, separator: { kind: "string" }, format: { kind: "enum", values: ["automatic", "raw", "preserve", "GNM_STF_FORMAT_AUTO", "GNM_STF_FORMAT_RAW", "GNM_STF_FORMAT_PRESERVE"] }, "transliterate-mode": { kind: "enum", values: ["transliterate", "escape", "GNM_STF_TRANSLITERATE_MODE_TRANS", "GNM_STF_TRANSLITERATE_MODE_ESCAPE"] }, "quoting-mode": { kind: "enum", values: ["never", "auto", "always", "GSF_OUTPUT_CSV_QUOTING_MODE_NEVER", "GSF_OUTPUT_CSV_QUOTING_MODE_AUTO", "GSF_OUTPUT_CSV_QUOTING_MODE_ALWAYS"] }, "quoting-on-whitespace": { kind: "boolean" } }, source: "src/stf-export.c:774" }, { id: "stf_csv", direction: "write", description: "Comma separated values (CSV)", extensions: ["csv"], byteStrings: "utf8-text", formatLevel: "manual_remember", saveScope: "sheet", sheetSelection: true, honorsExportRange: true, write: ve }] };
+var q = { id: "Gnumeric_stf", source: "src/stf.c", services: [{ id: "stf_csvtab", direction: "read", description: "Comma or tab separated values (CSV/TSV)", extensions: ["csv", "tsv", "txt"], mimeTypes: ["application/tab-separated-values", "text/comma-separated-values", "text/csv", "text/x-csv", "text/spreadsheet", "text/tab-separated-values"], probePriority: 0, contentProbe: true, encodingDependent: true, probeName: N, probeContent: fe, read: xe }, { id: "stf_assistant", direction: "read", description: "Text import (configurable)", extensions: [], mimeTypes: ["text/plain", "text/csv", "text/x-csv", "text/comma-separated-values", "text/tab-separated-values"], probePriority: 0, encodingDependent: true, interactiveOnly: true, read: he }, { id: "stf_assistant", direction: "write", description: "Text (configurable)", extensions: ["txt"], byteStrings: "utf8-text", sheetSelection: true, honorsExportRange: true, write: we, exportOptionRules: { eol: { kind: "enum", values: ["unix", "mac", "windows"], asciiCaseInsensitive: true, error: "eol must be one of unix, mac, and windows" }, charset: { kind: "string" }, locale: { kind: "string" }, quote: { kind: "string" }, separator: { kind: "string" }, format: { kind: "enum", values: ["automatic", "raw", "preserve", "GNM_STF_FORMAT_AUTO", "GNM_STF_FORMAT_RAW", "GNM_STF_FORMAT_PRESERVE"] }, "transliterate-mode": { kind: "enum", values: ["transliterate", "escape", "GNM_STF_TRANSLITERATE_MODE_TRANS", "GNM_STF_TRANSLITERATE_MODE_ESCAPE"] }, "quoting-mode": { kind: "enum", values: ["never", "auto", "always", "GSF_OUTPUT_CSV_QUOTING_MODE_NEVER", "GSF_OUTPUT_CSV_QUOTING_MODE_AUTO", "GSF_OUTPUT_CSV_QUOTING_MODE_ALWAYS"] }, "quoting-on-whitespace": { kind: "boolean" } }, source: "src/stf-export.c:774" }, { id: "stf_csv", direction: "write", description: "Comma separated values (CSV)", extensions: ["csv"], byteStrings: "utf8-text", formatLevel: "manual_remember", saveScope: "sheet", sheetSelection: true, honorsExportRange: true, write: ve }] };
 var ge = { id: "Gnumeric_sylk", services: [{ id: "sylk", direction: "read", probeContent: async (e, t) => (await import("./sylk-25D7TL2Y-RU6ANKGT.js")).probeSylk(e, t), read: async (e, t) => (await import("./sylk-25D7TL2Y-RU6ANKGT.js")).readSylk(e, t), description: "MultiPlan (SYLK)", extensions: ["slk", "sylk"], mimeTypes: ["application/x-sylk"], probePriority: 1, contentProbe: true }, { id: "sylk", direction: "write", write: async (e, t, n) => (await import("./sylk-25D7TL2Y-RU6ANKGT.js")).writeSylk(e, t, n), description: "MultiPlan (SYLK)", extensions: ["slk"], mimeTypes: ["application/x-sylk"], formatLevel: "auto", saveScope: "sheet", selectionSource: "view" }], source: "plugins/sylk/plugin.xml.in" };
 var D = { id: "Gnumeric_xbase", services: [{ id: "xbase", direction: "read", read: async (e, t) => (await import("./xbase-SNLCY6IW-DY6FAR6V.js")).readXbase(e, t), description: "Xbase (*.dbf) file format", extensions: ["dbf"], mimeTypes: ["application/dbase", "application/dbf", "application/x-dbase", "application/x-dbf", "application/x-xbase", "zz-application/zz-winassoc-dbf"], probePriority: 100 }], source: "plugins/xbase/plugin.xml.in" };
-var be = { id: "Gnumeric_XmlIO", source: "src/xml-sax-write.c", services: [{ id: "sax", direction: "read", description: "Gnumeric XML (*.gnumeric)", extensions: ["gnumeric", "xml"], filenameSuffixes: ["xml.gz"], mimeTypes: ["application/x-gnumeric"], contentProbe: true, source: "src/xml-sax-read.c:3901", probeContent: async (...e) => (await import("./gnumeric-OCFH63UT-YI7SG7TN.js")).probeGnumeric(...e), read: async (e, t) => (await import("./gnumeric-OCFH63UT-YI7SG7TN.js")).readGnumeric(e, t) }, { id: "sax", direction: "write", description: "Gnumeric XML (*.gnumeric)", extensions: ["gnumeric"], mimeTypes: ["application/x-gnumeric"], byteStrings: "formula-only", formatLevel: "auto", defaultSaverPriority: 50, write: async (e, t, n) => (await import("./gnumeric-OCFH63UT-YI7SG7TN.js")).writeCompressedGnumeric(e, t, n) }, { id: "sax:0", direction: "write", description: "Gnumeric XML uncompressed (*.xml)", extensions: ["xml"], mimeTypes: ["application/xml"], byteStrings: "formula-only", formatLevel: "auto", write: async (e, t, n) => (await import("./gnumeric-OCFH63UT-YI7SG7TN.js")).writeGnumeric(e, t, n) }] };
+var be = { id: "Gnumeric_XmlIO", source: "src/xml-sax-write.c", services: [{ id: "sax", direction: "read", description: "Gnumeric XML (*.gnumeric)", extensions: ["gnumeric", "xml"], filenameSuffixes: ["xml.gz"], mimeTypes: ["application/x-gnumeric"], contentProbe: true, source: "src/xml-sax-read.c:3901", probeContent: async (...e) => (await import("./gnumeric-ABKSRBZJ-MPIIPXKP.js")).probeGnumeric(...e), read: async (e, t) => (await import("./gnumeric-ABKSRBZJ-MPIIPXKP.js")).readGnumeric(e, t) }, { id: "sax", direction: "write", description: "Gnumeric XML (*.gnumeric)", extensions: ["gnumeric"], mimeTypes: ["application/x-gnumeric"], byteStrings: "formula-only", formatLevel: "auto", defaultSaverPriority: 50, write: async (e, t, n) => (await import("./gnumeric-ABKSRBZJ-MPIIPXKP.js")).writeCompressedGnumeric(e, t, n) }, { id: "sax:0", direction: "write", description: "Gnumeric XML uncompressed (*.xml)", extensions: ["xml"], mimeTypes: ["application/xml"], byteStrings: "formula-only", formatLevel: "auto", write: async (e, t, n) => (await import("./gnumeric-ABKSRBZJ-MPIIPXKP.js")).writeGnumeric(e, t, n) }] };
 var k = [X, B, $, Q, Y, Z, K, J, ee, te, R, ie, oe, ne, se, ae, ce, q, ge, D, be];
 var Ve = Object.freeze(Se([], k).coverage().map(({ installed: e, ...t }) => Object.freeze(t)));
 function Pe(e, t = k) {
@@ -462,8 +462,8 @@ function Ur(e = {}) {
   return He({ ...e, formats: t, codecs: n, fonts: "fonts" in e ? e.fonts : { async resolve() {
     let { suppliedDefaultFont: c } = await import("../../safe-bash-pdf-engine/index.js");
     return c().bytes;
-  } }, rendering: e.rendering ?? he(), clipboard: e.clipboard ?? { async serialize(c, i, x, m) {
-    let { serializeClipboard: p } = await import("./clipboard-XCSQACOK-SHFXT53F.js");
+  } }, rendering: e.rendering ?? g(), clipboard: e.clipboard ?? { async serialize(c, i, x, m) {
+    let { serializeClipboard: p } = await import("./clipboard-6SDGQGC3-TVJ3CG7A.js");
     return p(c, i, x, m, (l) => r.select("write", l));
   } } });
 }