@graphty/graph-io 0.3.40 → 0.3.42

package/src/common/lists.ts

@@ -144,21 +144,9 @@ function splitBracketed(text: string): string[] {
         }
         let item = "";
         if (i < n && (inner[i] === '"' || inner[i] === "'")) {
-            const quote = inner[i];
-            i++;
-            while (i < n) {
-                if (inner[i] === quote) {
-                    if (inner[i + 1] === quote) {
-                        item += quote;
-                        i += 2;
-                        continue;
-                    }
-                    i++;
-                    break;
-                }
-                item += inner[i];
-                i++;
-            }
+            const quoted = readQuoted(inner, i);
+            item = quoted.text;
+            i = quoted.end;
         }
         // unquoted text, or text after a closing quote that is not a separator, runs to the next comma
         let end = inner.indexOf(",", i);
@@ -179,6 +167,32 @@ function splitBracketed(text: string): string[] {
     }
 }
 
+/**
+ * Read a quoted item of a bracketed list: a doubled quote inside it is one quote, and a missing
+ * closing quote ends it at the end of the text.
+ * @param inner - the inside of the brackets
+ * @param open - the index of the opening quote
+ * @returns the unquoted text and the index just past the closing quote
+ */
+function readQuoted(inner: string, open: number): { text: string; end: number } {
+    const quote = inner[open];
+    const n = inner.length;
+    let text = "";
+    let i = open + 1;
+    while (i < n) {
+        if (inner[i] !== quote) {
+            text += inner[i];
+            i++;
+        } else if (inner[i + 1] === quote) {
+            text += quote;
+            i += 2;
+        } else {
+            return { text, end: i + 1 };
+        }
+    }
+    return { text, end: i };
+}
+
 /**
  * Whether a char code is ASCII whitespace.
  * @param c - the char code

package/src/common/text.ts

@@ -202,21 +202,7 @@ export class TextCellWriter {
     write(row: number, text: string): void {
         const kind = inferTextDtype(text);
         const value = parseTextCell(text);
-        if (
-            typeof value === "number" &&
-            !Number.isSafeInteger(value) &&
-            I32_TEXT.test(text) &&
-            BigInt(text) !== BigInt(value)
-        ) {
-            // an integer beyond 2^53 is stored as the nearest double; say so once per column
-            this.report.warnOnce(
-                "precision",
-                PRECISION_CODE,
-                `${this.domain} column "${this.name}": integers beyond 2^53 are stored as the nearest double (first: ${text})`,
-                { element: this.name },
-                `${PRECISION_CODE}:${this.domain}:${this.name}`,
-            );
-        }
+        this.warnIfImprecise(text, value);
         const wasString = this.textDtype === "string";
         const textDtype =
             this.textDtype === null || textDtypeRank(kind) > textDtypeRank(this.textDtype) ? kind : this.textDtype;
@@ -250,6 +236,29 @@ export class TextCellWriter {
         }
     }
 
+    /**
+     * Warn, once per column, when the cell is an integer beyond 2^53 that is stored as the nearest
+     * double.
+     * @param text - the cell text
+     * @param value - the parsed value
+     */
+    private warnIfImprecise(text: string, value: unknown): void {
+        if (
+            typeof value === "number" &&
+            !Number.isSafeInteger(value) &&
+            I32_TEXT.test(text) &&
+            BigInt(text) !== BigInt(value)
+        ) {
+            this.report.warnOnce(
+                "precision",
+                PRECISION_CODE,
+                `${this.domain} column "${this.name}": integers beyond 2^53 are stored as the nearest double (first: ${text})`,
+                { element: this.name },
+                `${PRECISION_CODE}:${this.domain}:${this.name}`,
+            );
+        }
+    }
+
     /**
      * Write a value (the parsed scalar, or a text into a widened column).
      * @param row - the row

package/src/common/zip.ts

@@ -134,6 +134,52 @@ export function startsLikeZip(bytes: Uint8Array): boolean {
     return bytes.byteLength >= 4 && bytes[0] === 0x50 && bytes[1] === 0x4b && bytes[2] === 3 && bytes[3] === 4;
 }
 
+/**
+ * Read the end of central directory record, following the zip64 locator when there is one.
+ * @param view - the whole archive
+ * @param eocd - the offset of the end record
+ * @returns the disk numbers, the entry count and where the central directory is; ZipError
+ * "corrupt" when the end record needs a zip64 record the archive does not have
+ */
+function readEndRecord(
+    view: DataView,
+    eocd: number,
+): {
+    disk: number;
+    directoryDisk: number;
+    count: number;
+    directorySize: number;
+    directoryOffset: number;
+    directoryEnd: number;
+} {
+    const locator = eocd - ZIP64_LOCATOR_SIZE;
+    if (locator >= 0 && view.getUint32(locator, true) === ZIP64_LOCATOR_SIGNATURE) {
+        const record = zip64EndRecord(view, locator);
+        return {
+            disk: view.getUint32(record + 16, true),
+            directoryDisk: view.getUint32(record + 20, true),
+            count: readU64(view, record + 32),
+            directorySize: readU64(view, record + 40),
+            directoryOffset: readU64(view, record + 48),
+            directoryEnd: record,
+        };
+    }
+    const count = view.getUint16(eocd + 10, true);
+    const directorySize = view.getUint32(eocd + 12, true);
+    const directoryOffset = view.getUint32(eocd + 16, true);
+    if (count === U16_MAX || directorySize === U32_MAX || directoryOffset === U32_MAX) {
+        throw new ZipError("corrupt", "the end record needs a zip64 record the archive does not have");
+    }
+    return {
+        disk: view.getUint16(eocd + 4, true),
+        directoryDisk: view.getUint16(eocd + 6, true),
+        count,
+        directorySize,
+        directoryOffset,
+        directoryEnd: eocd,
+    };
+}
+
 /**
  * Read the central directory.
  * @param bytes - the whole archive
@@ -150,24 +196,7 @@ export function readZipDirectory(bytes: Uint8Array): ZipEntry[] {
             ? new ZipError("corrupt", "the archive has no end of central directory record (truncated?)")
             : new ZipError("not-zip", "the input is not a zip archive");
     }
-    let disk = view.getUint16(eocd + 4, true);
-    let directoryDisk = view.getUint16(eocd + 6, true);
-    let count = view.getUint16(eocd + 10, true);
-    let directorySize = view.getUint32(eocd + 12, true);
-    let directoryOffset = view.getUint32(eocd + 16, true);
-    let directoryEnd = eocd;
-    const locator = eocd - ZIP64_LOCATOR_SIZE;
-    if (locator >= 0 && view.getUint32(locator, true) === ZIP64_LOCATOR_SIGNATURE) {
-        const record = zip64EndRecord(view, locator);
-        disk = view.getUint32(record + 16, true);
-        directoryDisk = view.getUint32(record + 20, true);
-        count = readU64(view, record + 32);
-        directorySize = readU64(view, record + 40);
-        directoryOffset = readU64(view, record + 48);
-        directoryEnd = record;
-    } else if (count === U16_MAX || directorySize === U32_MAX || directoryOffset === U32_MAX) {
-        throw new ZipError("corrupt", "the end record needs a zip64 record the archive does not have");
-    }
+    const { disk, directoryDisk, count, directorySize, directoryOffset, directoryEnd } = readEndRecord(view, eocd);
     if (disk !== 0 || directoryDisk !== 0) {
         throw new ZipError("unsupported", "a split (multi-disk) archive cannot be read");
     }