@graphty/graph-io 0.3.43 → 0.3.44

package/dist/chunks/format-GDmO6m6Q.js

@@ -0,0 +1,676 @@
+import { GraphFormatError } from "@graphty/graph-format";
+const FETCH_CODE = "E_FETCH";
+const MISSING_ID_CODE = "E_MISSING_ID";
+const MISSING_ENDPOINT_CODE = "E_MISSING_ENDPOINT";
+const DUPLICATE_NODE_CODE = "W_DUPLICATE_NODE";
+const NO_GRAPH_CODE = "E_NO_GRAPH";
+const MULTIPLE_GRAPHS_CODE = "W_MULTIPLE_GRAPHS";
+const EMPTY_INPUT_CODE = "E_EMPTY_INPUT";
+const SYNTAX_CODE = "E_SYNTAX";
+const XML_SYNTAX_CODE = "E_XML_SYNTAX";
+const XML_NESTING_CODE = "E_XML_NESTING";
+const UNKNOWN_ELEMENT_CODE = "W_UNKNOWN_ELEMENT";
+const STRAY_TEXT_CODE = "W_STRAY_TEXT";
+const UNKNOWN_PARENT_CODE = "E_UNKNOWN_PARENT";
+const HYPEREDGE_CODE = "E_HYPEREDGE";
+const DUPLICATE_KEY_CODE = "E_DUPLICATE_KEY";
+const COLUMN_RENAMED_CODE = "W_COLUMN_RENAMED";
+const COLUMN_DROPPED_CODE = "W_COLUMN_DROPPED";
+const ROLE_TAKEN_CODE = "W_ROLE_TAKEN";
+const PRECISION_CODE = "W_PRECISION";
+const ID_MERGED_CODE = "W_ID_MERGED";
+const SINK_OPTION_CODE = "W_SINK_OPTION";
+const OPTION_IGNORED_CODE = "W_OPTION_IGNORED";
+const INVALID_UTF8_CODE = "E_INVALID_UTF8";
+const INVALID_ENCODING_CODE = "E_INVALID_ENCODING";
+const ENCODING_FALLBACK_CODE = "W_ENCODING_FALLBACK";
+const UNKNOWN_ENCODING_CODE = "W_UNKNOWN_ENCODING";
+const ENCODING_CONFLICT_CODE = "W_ENCODING_CONFLICT";
+const CONTROL_CHARACTER_CODE = "W_CONTROL_CHARACTER";
+const FOREIGN_FORMAT_CODE = "E_FOREIGN_FORMAT";
+const ISSUES_SUPPRESSED_CODE = "W_ISSUES_SUPPRESSED";
+const UNKNOWN_XML_ATTRIBUTE_CODE = "W_UNKNOWN_XML_ATTRIBUTE";
+const DIRECTION_REFUSED_CODE = "W_DIRECTION_REFUSED";
+const DIRECTION_FORCED_CODE = "W_DIRECTION_FORCED";
+const MIXED_DIRECTION_CODE = "E_MIXED_DIRECTION";
+const COUNT_HINT_CODE = "W_COUNT_HINT";
+const UNKNOWN_ATTR_TYPE_CODE = "W_UNKNOWN_ATTR_TYPE";
+const BAD_DEFAULT_CODE = "W_BAD_DEFAULT";
+const BAD_OPTIONS_CODE = "W_BAD_OPTIONS";
+const DUPLICATE_EDGE_ID_CODE = "E_DUPLICATE_EDGE_ID";
+const BAD_VALUE_CODE = "E_BAD_VALUE";
+const WIDENED_CODE = "W_WIDENED";
+const DANGLING_REFERENCE_CODE = "W_DANGLING_REFERENCE";
+const DUPLICATE_ATTRIBUTE_CODE = "W_DUPLICATE_ATTRIBUTE";
+const PARENT_CYCLE_CODE = "E_PARENT_CYCLE";
+const EQUATION_AS_TEXT_CODE = "W_EQUATION_AS_TEXT";
+const STYLES_NOT_IMPORTED_CODE = "W_STYLES_NOT_IMPORTED";
+const BAD_ASPECT_BLOCK_CODE = "E_BAD_ASPECT_BLOCK";
+const MULTI_ASPECT_FRAGMENT_CODE = "W_MULTI_ASPECT_FRAGMENT";
+const SINGLE_OBJECT_ASPECT_CODE = "W_SINGLE_OBJECT_ASPECT";
+const JSON_NONSTANDARD_NUMBER_CODE = "W_JSON_NONSTANDARD_NUMBER";
+const ASPECT_ORDER_CODE = "W_ASPECT_ORDER";
+const COUNT_MISMATCH_CODE = "W_COUNT_MISMATCH";
+const STATUS_FAILED_CODE = "E_STATUS_FAILED";
+const STATUS_WARNING_CODE = "W_STATUS_WARNING";
+const TOO_LARGE_CODE = "E_TOO_LARGE";
+const COLUMN_TYPE_CODE = "E_COLUMN_TYPE";
+const GRAPH_NOT_FOUND_CODE = "E_GRAPH_NOT_FOUND";
+const AMBIGUOUS_GRAPH_NAME_CODE = "E_AMBIGUOUS_GRAPH_NAME";
+const DUPLICATE_EDGE_CODE = "E_DUPLICATE_EDGE";
+const SELF_LOOP_CODE = "E_SELF_LOOP";
+const EDGES_MERGED_CODE = "W_EDGES_MERGED";
+const SELF_LOOPS_DROPPED_CODE = "W_SELF_LOOPS_DROPPED";
+const UNKNOWN_OPTION_CODE = "W_UNKNOWN_OPTION";
+const BAD_LINE_CODE = "E_BAD_LINE";
+const WEIGHT_NOT_FOUND_CODE = "W_WEIGHT_NOT_FOUND";
+const ROLE_DROPPED_CODE = "W_ROLE_DROPPED";
+const PARENTS_DROPPED_CODE = "W_PARENTS_DROPPED";
+const TEMPORAL_DROPPED_CODE = "W_TEMPORAL_DROPPED";
+const MUTUAL_EXPANDED_CODE = "W_MUTUAL_EXPANDED";
+const MUTUAL_AS_UNDIRECTED_CODE = "W_MUTUAL_AS_UNDIRECTED";
+const ID_TEXT_TYPE_CODE = "W_ID_TEXT_TYPE";
+const ID_TEXT_COLLISION_CODE = "E_ID_TEXT_COLLISION";
+const TEMPORAL_TEXT_DROPPED_CODE = "W_TEMPORAL_TEXT_DROPPED";
+const WEIGHTS_DROPPED_CODE = "W_WEIGHTS_DROPPED";
+const WEIGHT_KEY_CLASH_CODE = "W_WEIGHT_KEY_CLASH";
+const ROLE_ASSUMED_CODE = "W_ROLE_ASSUMED";
+const COLUMN_RENAMED_LOSS_CODE = "W_COLUMN_NAME_CHANGED";
+const EMPTY_COLUMN_DROPPED_CODE = "W_EMPTY_COLUMN_DROPPED";
+const STORAGE_CLASS_CODE = "W_STORAGE_CLASS_CHANGED";
+const INTEGRAL_F64_CODE = "W_INTEGRAL_F64_AS_I32";
+const TEXT_INFERRED_CODE = "W_TEXT_INFERRED";
+const XML_ILLEGAL_CHAR_CODE = "E_XML_ILLEGAL_CHAR";
+const COLUMN_AS_PROPERTY_VALUE_CODE = "W_COLUMN_AS_PROPERTY_VALUE";
+const RELATION_ASSUMED_CODE = "W_RELATION_ASSUMED";
+const TYPEDEF_NODES_CODE = "W_TYPEDEF_NODES";
+const GRAPH_COLUMN_AS_METADATA_CODE = "W_GRAPH_COLUMN_AS_METADATA";
+const DIRECTION_DROPPED_CODE = "W_DIRECTION_DROPPED";
+const NONFINITE_AS_NULL_CODE = "W_NONFINITE_AS_NULL";
+const NODE_ORDER_CODE = "W_NODE_ORDER";
+const OPTIONS_GAINED_CODE = "W_OPTIONS_GAINED";
+const ELEMENT_ISSUE = Object.freeze({
+  /** A node id of a type the graph cannot hold (an empty id, a non-finite number, an object). The node is skipped. */
+  INVALID_ID: "E_INVALID_ID",
+  /** An edge names a node the file never declares, while `addMissingNodes` is false. The edge is skipped. */
+  UNKNOWN_NODE: "E_UNKNOWN_NODE",
+  /**
+   * An edge weight that is not a number (text such as "2,5" with a decimal comma, NaN, a boolean). The whole edge is
+   * skipped, not only its weight.
+   */
+  INVALID_WEIGHT: "E_INVALID_WEIGHT",
+  /** A second edge between the same two nodes, while `duplicateEdges` is "error". The edge is skipped. */
+  DUPLICATE_EDGE: DUPLICATE_EDGE_CODE,
+  /** An edge from a node to itself, while `selfLoops` is "error". The edge is skipped. */
+  SELF_LOOP: SELF_LOOP_CODE,
+  /** An edge id declared twice. The second edge is skipped. */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE
+});
+const INPUT_ISSUE = Object.freeze({
+  /** The input is empty or holds only whitespace. The import stops. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The input, or one of its lines, is longer than a JavaScript string can hold. The import stops. */
+  TOO_LARGE: TOO_LARGE_CODE,
+  /** A byte order mark, the encoding option and the declared encoding disagree. */
+  ENCODING_CONFLICT: ENCODING_CONFLICT_CODE,
+  /** A control character or a stray U+FEFF in the text, or an ignored trailing Ctrl-Z. */
+  CONTROL_CHARACTER: CONTROL_CHARACTER_CODE,
+  /** The input is an HTML page, a PDF, compressed or zip data, or an image. The import stops. */
+  FOREIGN_FORMAT: FOREIGN_FORMAT_CODE,
+  /** Warnings of one code beyond the number a report keeps, counted in one warning. */
+  ISSUES_SUPPRESSED: ISSUES_SUPPRESSED_CODE
+});
+function plural(n) {
+  return n === 1 ? "" : "s";
+}
+function agree(n, one, many) {
+  return n === 1 ? one : many;
+}
+function elementCount(nodes, edges) {
+  const parts = [];
+  if (nodes > 0 || edges === 0) {
+    parts.push(`${nodes} node${plural(nodes)}`);
+  }
+  if (edges > 0) {
+    parts.push(`${edges} edge${plural(edges)}`);
+  }
+  return parts.join(" and ");
+}
+function withArticle(word) {
+  return `${/^[aeiou]/i.test(word) ? "an" : "a"} ${word}`;
+}
+class ImportError extends GraphFormatError {
+  /**
+   * Create an ImportError.
+   * @param message - a plain-ASCII human-readable message
+   * @param report - the partial report
+   * @param details - optional machine-readable context; its `code` names the issue that stopped the import
+   */
+  constructor(message, report, details) {
+    super("E_IMPORT", message, details);
+    this.name = "ImportError";
+    Object.defineProperty(this, "report", { value: report, enumerable: false });
+    this.issue = stoppingIssue(report.issues, details?.code);
+  }
+}
+function stoppingIssue(issues, code) {
+  let lastError = null;
+  for (let i = issues.length - 1; i >= 0; i--) {
+    if (issues[i].code === code) {
+      return issues[i];
+    }
+    if (lastError === null && issues[i].severity === "error") {
+      lastError = issues[i];
+    }
+  }
+  return lastError;
+}
+const MAX_WARNINGS_PER_CODE = 1e3;
+const KEPT_FOR_STYLES = /* @__PURE__ */ new WeakMap();
+const NOTHING_KEPT = /* @__PURE__ */ Symbol("nothing kept");
+function keptForStyles(report) {
+  return KEPT_FOR_STYLES.get(report);
+}
+const CATEGORY_BY_CODE = {
+  E_UNKNOWN_NODE: "missing-value",
+  E_UNKNOWN_COLUMN: "missing-value",
+  E_DIRECTED: "coercion",
+  E_TOO_LARGE: "unsupported",
+  E_UNSUPPORTED: "unsupported",
+  E_GPU_INELIGIBLE: "unsupported"
+};
+const PARSE_ERROR_CODE = "E_PARSE";
+function withLine(message, where) {
+  const line = where?.line;
+  return line === void 0 || line === null || message.includes(`line ${line}`) ? message : `line ${line}: ${message}`;
+}
+class ImportReportBuilder {
+  /**
+   * Create a builder for one import call.
+   * @param format - the importer's format name
+   * @param errorLimit - errors tolerated before the import aborts; Infinity for no limit
+   */
+  constructor(format, errorLimit) {
+    this.counts = { nodes: 0, edges: 0, skippedNodes: 0, skippedEdges: 0, expandedMixed: 0 };
+    this.issueList = [];
+    this.lossList = [];
+    this.onceCodes = /* @__PURE__ */ new Set();
+    this.warningsByCode = /* @__PURE__ */ new Map();
+    this.errors = 0;
+    this.warnings = 0;
+    this.truncatedFlag = false;
+    this.kept = NOTHING_KEPT;
+    this.format = format;
+    this.errorLimit = errorLimit;
+    this.startedAt = now();
+  }
+  /**
+   * Issues recorded so far, in order.
+   * @returns the live list (not copied; finish() copies)
+   */
+  get issues() {
+    return this.issueList;
+  }
+  /**
+   * Issues with severity "error".
+   * @returns the count
+   */
+  get errorCount() {
+    return this.errors;
+  }
+  /**
+   * Issues with severity "warning".
+   * @returns the count
+   */
+  get warningCount() {
+    return this.warnings;
+  }
+  /**
+   * Whether the error limit was exceeded.
+   * @returns true once an error beyond the limit was recorded
+   */
+  get truncated() {
+    return this.truncatedFlag;
+  }
+  /**
+   * Loss notes recorded so far.
+   * @returns the live list
+   */
+  get lossy() {
+    return this.lossList;
+  }
+  /**
+   * Record an error. When the count goes beyond the error limit the report is marked truncated
+   * and an ImportError carrying it is thrown; the importer does not catch that.
+   * @param category - the issue category
+   * @param code - a stable code such as "E_UNKNOWN_NODE"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  error(category, code, message, where) {
+    const issue = makeIssue(category, "error", code, message, where);
+    this.issueList.push(issue);
+    this.errors++;
+    if (this.errors > this.errorLimit) {
+      this.truncatedFlag = true;
+      throw this.abort(`error limit of ${this.errorLimit} exceeded: ${withLine(message, where)}`, {
+        code,
+        limit: this.errorLimit
+      });
+    }
+    return issue;
+  }
+  /**
+   * Record a warning; warnings never count toward the limit. Beyond MAX_WARNINGS_PER_CODE
+   * warnings of one code the warning is counted, not kept: finish() adds one W_ISSUES_SUPPRESSED
+   * warning per such code with the number dropped.
+   * @param category - the issue category
+   * @param code - a stable code such as "W_WIDENED"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  warning(category, code, message, where) {
+    const issue = makeIssue(category, "warning", code, message, where);
+    const seen = (this.warningsByCode.get(code) ?? 0) + 1;
+    this.warningsByCode.set(code, seen);
+    if (seen <= MAX_WARNINGS_PER_CODE) {
+      this.issueList.push(issue);
+      this.warnings++;
+    }
+    return issue;
+  }
+  /**
+   * Record a warning the first time its key is seen and ignore later repeats, for conditions
+   * that would otherwise produce one warning per row.
+   * @param category - the issue category
+   * @param code - the stable code
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param key - what repeats are deduplicated on; the code itself by default (pass `code:column`
+   * to warn once per column)
+   * @returns the recorded issue, or null when the key was already recorded
+   */
+  warnOnce(category, code, message, where, key = code) {
+    if (this.onceCodes.has(key)) {
+      return null;
+    }
+    this.onceCodes.add(key);
+    return this.warning(category, code, message, where);
+  }
+  /**
+   * Record something the importer could not represent.
+   * @param code - a stable code
+   * @param message - a plain-ASCII message
+   * @param column - the affected column, or null
+   * @param count - the affected count, or null
+   * @returns the recorded note
+   */
+  loss(code, message, column = null, count = null) {
+    const note = Object.freeze({ code, message, column, count });
+    this.lossList.push(note);
+    return note;
+  }
+  /**
+   * The per-element catch: record a thrown GraphFormatError as an error
+   * issue with its code and the category the code implies. Anything else is re-thrown unchanged:
+   * an ImportError (the import already aborted), an abort reason, and any other thrown value (a
+   * TypeError or RangeError is a programming error in the importer or the sink, never a defect of
+   * the input, so it must surface as an exception rather than as an issue blamed on the file).
+   * @param err - the thrown value
+   * @param where - the line and element, when known
+   * @returns the recorded issue
+   */
+  recordError(err, where) {
+    if (err instanceof GraphFormatError && !(err instanceof ImportError)) {
+      const category = CATEGORY_BY_CODE[err.code] ?? "validation-error";
+      if (err.code === "E_TOO_LARGE") {
+        return this.failWith(category, err.code, err.message, where);
+      }
+      return this.error(category, err.code, err.message, where);
+    }
+    throw err;
+  }
+  /**
+   * Keep style data that is not per element (a stylesheet, a groups object, a legend, the file's default styles)
+   * for this import's `styles()`: graph-io passes it back as `context.kept` when styles are requested. Kept per
+   * report, never on the importer object, so imports running at once each get their own. A later call replaces
+   * the value.
+   * @param value - anything the importer's `styles()` needs
+   * @returns this builder
+   */
+  keepForStyles(value) {
+    this.kept = value;
+    return this;
+  }
+  /**
+   * A builder that starts from everything this one recorded so far: issues, counts, loss notes,
+   * the warnOnce keys, the error and warning counts and the truncation flag. For an importer that
+   * reads its input once and emits several graphs, each with its own report.
+   * @returns the copy; later records to either builder do not reach the other
+   */
+  fork() {
+    const copy = new ImportReportBuilder(this.format, this.errorLimit);
+    Object.assign(copy.counts, this.counts);
+    copy.issueList.push(...this.issueList);
+    copy.lossList.push(...this.lossList);
+    for (const key of this.onceCodes) {
+      copy.onceCodes.add(key);
+    }
+    for (const [code, count] of this.warningsByCode) {
+      copy.warningsByCode.set(code, count);
+    }
+    copy.errors = this.errors;
+    copy.warnings = this.warnings;
+    copy.truncatedFlag = this.truncatedFlag;
+    copy.kept = this.kept;
+    return copy;
+  }
+  /**
+   * Build the ImportError that aborts the import, carrying the report so far. The caller throws
+   * it; this method only constructs it so it can be used in expression position.
+   * @param message - a plain-ASCII message
+   * @param details - optional machine-readable context
+   * @returns the error to throw
+   */
+  abort(message, details) {
+    return new ImportError(message, this.finish(), details);
+  }
+  /**
+   * Record a fatal parse error and abort: the issue is recorded (even beyond the error limit)
+   * and an ImportError carrying the report is thrown.
+   * @param code - a stable code such as "E_INVALID_UTF8"
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param details - optional machine-readable context for the ImportError
+   */
+  fail(code, message, where, details) {
+    this.failWith("parse-error", code, message, where, details);
+  }
+  /**
+   * Record a fatal error of any category and abort, as fail() does for a parse error: a size
+   * limit (E_TOO_LARGE, category "unsupported") stops an import without being a defect of the
+   * syntax. A fatal error is not the error limit: `truncated` stays as it was.
+   * @param category - the issue category
+   * @param code - a stable code
+   * @param message - a plain-ASCII message
+   * @param where - the line and element, when known
+   * @param details - optional machine-readable context for the ImportError
+   */
+  failWith(category, code, message, where, details) {
+    this.issueList.push(makeIssue(category, "error", code, message, where));
+    this.errors++;
+    throw this.abort(withLine(message, where), { code, ...details });
+  }
+  /**
+   * Add a finished report to this one: its issues after the ones recorded so far, its counts, its
+   * loss notes and its truncated flag. Use it when an importer hands part of the work to another
+   * importer (for example, a wrapper around the CSV importer) and returns one report for both. The issues
+   * keep their codes; errors added this way do not count toward this report's error limit, since
+   * the other importer applied its own.
+   * @param report - the report the other importer returned
+   * @returns this builder
+   * @example
+   * ```ts
+   * const report = new ImportReportBuilder("netscope", opts.errorLimit);
+   * const text = await readText(input, report, opts);
+   * report.include(await csvImporter.import(text, sink, options));
+   * return report.finish();
+   * ```
+   */
+  include(report) {
+    for (const issue of report.issues) {
+      this.issueList.push(issue);
+      if (issue.severity === "error") {
+        this.errors++;
+      } else {
+        this.warnings++;
+      }
+    }
+    const { counts } = report;
+    this.counts.nodes += counts.nodes;
+    this.counts.edges += counts.edges;
+    this.counts.skippedNodes += counts.skippedNodes;
+    this.counts.skippedEdges += counts.skippedEdges;
+    this.counts.expandedMixed += counts.expandedMixed;
+    this.lossList.push(...report.lossy);
+    this.truncatedFlag ||= report.truncated;
+    if (this.kept === NOTHING_KEPT && KEPT_FOR_STYLES.has(report)) {
+      this.kept = KEPT_FOR_STYLES.get(report);
+    }
+    return this;
+  }
+  /**
+   * The report as it stands: a frozen snapshot with the parse duration so far. Can be called more
+   * than once; each call reflects everything recorded up to that point.
+   * @returns the report
+   */
+  finish() {
+    const { nodes, edges, skippedNodes, skippedEdges, expandedMixed } = this.counts;
+    const suppressed = [];
+    for (const [code, seen] of this.warningsByCode) {
+      if (seen > MAX_WARNINGS_PER_CODE) {
+        const more = seen - MAX_WARNINGS_PER_CODE;
+        suppressed.push(
+          makeIssue(
+            "unsupported",
+            "warning",
+            ISSUES_SUPPRESSED_CODE,
+            `${more} more ${code} warning${plural(more)} ${agree(more, "was", "were")} not kept (the report keeps the first ${MAX_WARNINGS_PER_CODE})`,
+            { element: code }
+          )
+        );
+      }
+    }
+    const report = Object.freeze({
+      format: this.format,
+      counts: Object.freeze({ nodes, edges, skippedNodes, skippedEdges, expandedMixed }),
+      issues: Object.freeze([...this.issueList, ...suppressed]),
+      errorCount: this.errors,
+      warningCount: this.warnings + suppressed.length,
+      truncated: this.truncatedFlag,
+      lossy: Object.freeze([...this.lossList]),
+      durationMs: now() - this.startedAt
+    });
+    if (this.kept !== NOTHING_KEPT) {
+      KEPT_FOR_STYLES.set(report, this.kept);
+    }
+    return report;
+  }
+}
+function makeIssue(category, severity, code, message, where) {
+  return Object.freeze({
+    category,
+    severity,
+    code,
+    message,
+    line: where?.line ?? null,
+    element: where?.element ?? null
+  });
+}
+function isAbortError(err) {
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const { name } = err;
+  return name === "AbortError" || name === "TimeoutError";
+}
+function messageOf(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  return `non-error thrown (${typeof err})`;
+}
+function now() {
+  return typeof performance === "object" ? performance.now() : Date.now();
+}
+function formatF32(value) {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  if (value === 0) {
+    return Object.is(value, -0) ? "-0" : "0";
+  }
+  for (let digits = 1; digits <= 9; digits++) {
+    const text = value.toPrecision(digits);
+    if (Math.fround(Number(text)) === value) {
+      return String(Number(text));
+    }
+  }
+  return String(value);
+}
+function formatF64(value) {
+  return Object.is(value, -0) ? "-0" : String(value);
+}
+function idText(id) {
+  return typeof id === "number" ? formatF64(id) : id;
+}
+function formatDecimal(value, dtype = "f64") {
+  if (!Number.isFinite(value)) {
+    return String(value);
+  }
+  if (Object.is(value, -0)) {
+    return "-0.0";
+  }
+  const text = formatNumber(value, dtype);
+  return text.includes(".") || text.includes("e") ? text : `${text}.0`;
+}
+function formatGmlReal(value, dtype = "f64") {
+  if (Number.isNaN(value)) {
+    return "NAN";
+  }
+  if (!Number.isFinite(value)) {
+    return value > 0 ? "+INF" : "-INF";
+  }
+  const text = formatDecimal(value, dtype);
+  if (text.includes(".")) {
+    return text;
+  }
+  const e = text.indexOf("e");
+  return `${text.slice(0, e)}.0${text.slice(e)}`;
+}
+function formatInteger(value) {
+  if (Number.isSafeInteger(value) || !Number.isFinite(value)) {
+    return String(value);
+  }
+  return BigInt(value).toString();
+}
+function formatNumber(value, dtype) {
+  return dtype === "f32" ? formatF32(value) : formatF64(value);
+}
+export {
+  formatF32 as $,
+  ROLE_DROPPED_CODE as A,
+  BAD_DEFAULT_CODE as B,
+  COLUMN_RENAMED_CODE as C,
+  DIRECTION_FORCED_CODE as D,
+  EMPTY_INPUT_CODE as E,
+  PARENTS_DROPPED_CODE as F,
+  MUTUAL_AS_UNDIRECTED_CODE as G,
+  HYPEREDGE_CODE as H,
+  ID_MERGED_CODE as I,
+  BAD_ASPECT_BLOCK_CODE as J,
+  MULTI_ASPECT_FRAGMENT_CODE as K,
+  ASPECT_ORDER_CODE as L,
+  MIXED_DIRECTION_CODE as M,
+  NO_GRAPH_CODE as N,
+  OPTION_IGNORED_CODE as O,
+  PRECISION_CODE as P,
+  STATUS_FAILED_CODE as Q,
+  ROLE_TAKEN_CODE as R,
+  SINK_OPTION_CODE as S,
+  STATUS_WARNING_CODE as T,
+  UNKNOWN_ATTR_TYPE_CODE as U,
+  agree as V,
+  JSON_NONSTANDARD_NUMBER_CODE as W,
+  XML_NESTING_CODE as X,
+  BAD_VALUE_CODE as Y,
+  ImportReportBuilder as Z,
+  idText as _,
+  DIRECTION_REFUSED_CODE as a,
+  formatF64 as a0,
+  TOO_LARGE_CODE as a1,
+  AMBIGUOUS_GRAPH_NAME_CODE as a2,
+  GRAPH_NOT_FOUND_CODE as a3,
+  SINGLE_OBJECT_ASPECT_CODE as a4,
+  STYLES_NOT_IMPORTED_CODE as a5,
+  PARENT_CYCLE_CODE as a6,
+  WIDENED_CODE as a7,
+  SYNTAX_CODE as a8,
+  COLUMN_AS_PROPERTY_VALUE_CODE as a9,
+  ID_TEXT_COLLISION_CODE as aA,
+  INTEGRAL_F64_CODE as aB,
+  ISSUES_SUPPRESSED_CODE as aC,
+  MUTUAL_EXPANDED_CODE as aD,
+  NONFINITE_AS_NULL_CODE as aE,
+  OPTIONS_GAINED_CODE as aF,
+  PARSE_ERROR_CODE as aG,
+  SELF_LOOP_CODE as aH,
+  STORAGE_CLASS_CODE as aI,
+  TEMPORAL_DROPPED_CODE as aJ,
+  TEMPORAL_TEXT_DROPPED_CODE as aK,
+  TEXT_INFERRED_CODE as aL,
+  WEIGHTS_DROPPED_CODE as aM,
+  WEIGHT_KEY_CLASH_CODE as aN,
+  formatDecimal as aO,
+  formatGmlReal as aP,
+  keptForStyles as aQ,
+  withArticle as aR,
+  elementCount as aS,
+  ROLE_ASSUMED_CODE as aa,
+  formatNumber as ab,
+  XML_ILLEGAL_CHAR_CODE as ac,
+  formatInteger as ad,
+  BAD_OPTIONS_CODE as ae,
+  NODE_ORDER_CODE as af,
+  GRAPH_COLUMN_AS_METADATA_CODE as ag,
+  TYPEDEF_NODES_CODE as ah,
+  RELATION_ASSUMED_CODE as ai,
+  isAbortError as aj,
+  BAD_LINE_CODE as ak,
+  messageOf as al,
+  UNKNOWN_OPTION_CODE as am,
+  ImportError as an,
+  FETCH_CODE as ao,
+  EDGES_MERGED_CODE as ap,
+  SELF_LOOPS_DROPPED_CODE as aq,
+  WEIGHT_NOT_FOUND_CODE as ar,
+  COLUMN_DROPPED_CODE as as,
+  COLUMN_RENAMED_LOSS_CODE as at,
+  CONTROL_CHARACTER_CODE as au,
+  DIRECTION_DROPPED_CODE as av,
+  DUPLICATE_EDGE_CODE as aw,
+  EMPTY_COLUMN_DROPPED_CODE as ax,
+  EQUATION_AS_TEXT_CODE as ay,
+  FOREIGN_FORMAT_CODE as az,
+  STRAY_TEXT_CODE as b,
+  UNKNOWN_ELEMENT_CODE as c,
+  UNKNOWN_XML_ATTRIBUTE_CODE as d,
+  DANGLING_REFERENCE_CODE as e,
+  COUNT_MISMATCH_CODE as f,
+  COUNT_HINT_CODE as g,
+  MULTIPLE_GRAPHS_CODE as h,
+  DUPLICATE_EDGE_ID_CODE as i,
+  DUPLICATE_NODE_CODE as j,
+  DUPLICATE_ATTRIBUTE_CODE as k,
+  UNKNOWN_PARENT_CODE as l,
+  MISSING_ENDPOINT_CODE as m,
+  MISSING_ID_CODE as n,
+  DUPLICATE_KEY_CODE as o,
+  plural as p,
+  ENCODING_CONFLICT_CODE as q,
+  UNKNOWN_ENCODING_CODE as r,
+  ENCODING_FALLBACK_CODE as s,
+  INVALID_ENCODING_CODE as t,
+  INVALID_UTF8_CODE as u,
+  XML_SYNTAX_CODE as v,
+  COLUMN_TYPE_CODE as w,
+  ELEMENT_ISSUE as x,
+  INPUT_ISSUE as y,
+  ID_TEXT_TYPE_CODE as z
+};
+//# sourceMappingURL=format-GDmO6m6Q.js.map