@johnhenry/sitefile 0.0.0-stage → 0.0.1

package/lib/src/csv.js

@@ -0,0 +1,117 @@
+import { SitefileError } from './errors.js';
+export function parseCsv(text, file, options = {}) {
+    const header = options.header ?? true;
+    const delim = options.delimiter ?? ',';
+    const rows = tokenize(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text, file, delim);
+    if (!header)
+        return rows.map((r) => r.fields);
+    const head = rows[0];
+    if (!head)
+        return [];
+    const seen = new Set();
+    head.fields.forEach((name, i) => {
+        const span = { file, line: head.line, column: head.cols[i] };
+        if (name === '')
+            throw new SitefileError('E_DATA', `empty CSV column name in header (column ${i + 1})`, span);
+        if (seen.has(name))
+            throw new SitefileError('E_DATA', `duplicate CSV column name '${name}'`, span);
+        seen.add(name);
+    });
+    return rows.slice(1).map((row) => {
+        if (row.fields.length !== head.fields.length) {
+            throw new SitefileError('E_DATA', `expected ${head.fields.length} field${head.fields.length === 1 ? '' : 's'} but found ${row.fields.length}`, { file, line: row.line, column: 1 });
+        }
+        // fromEntries defines own data properties, so `__proto__` is safe.
+        return Object.fromEntries(head.fields.map((name, i) => [name, row.fields[i]]));
+    });
+}
+export function parseCsvRecords(text, file) {
+    return parseCsv(text, file, { header: true });
+}
+function tokenize(text, file, delim) {
+    const n = text.length;
+    const rows = [];
+    let i = 0;
+    let line = 1;
+    let lineStart = 0;
+    const fail = (detail, l, index, ls) => {
+        throw new SitefileError('E_DATA', detail, { file, line: l, column: index - ls + 1 });
+    };
+    while (i < n) {
+        // Skip fully empty lines.
+        if (text[i] === '\n') {
+            i++;
+            line++;
+            lineStart = i;
+            continue;
+        }
+        if (text[i] === '\r' && text[i + 1] === '\n') {
+            i += 2;
+            line++;
+            lineStart = i;
+            continue;
+        }
+        const row = { fields: [], cols: [], line };
+        for (;;) {
+            row.cols.push(i - lineStart + 1);
+            let field = '';
+            if (text[i] === '"') {
+                const qLine = line;
+                const qIndex = i;
+                const qStart = lineStart;
+                i++;
+                for (;;) {
+                    if (i >= n)
+                        return fail('unterminated quoted field', qLine, qIndex, qStart);
+                    const c = text[i];
+                    if (c === '"') {
+                        if (text[i + 1] === '"') {
+                            field += '"';
+                            i += 2;
+                            continue;
+                        }
+                        i++;
+                        break;
+                    }
+                    if (c === '\n') {
+                        line++;
+                        lineStart = i + 1;
+                    }
+                    field += c;
+                    i++;
+                }
+                const after = text[i];
+                const atEnd = i >= n || after === delim || after === '\n' || (after === '\r' && text[i + 1] === '\n');
+                if (!atEnd)
+                    return fail('unexpected character after closing quote', line, i, lineStart);
+            }
+            else {
+                const s = i;
+                while (i < n) {
+                    const c = text[i];
+                    if (c === delim || c === '\n' || (c === '\r' && text[i + 1] === '\n'))
+                        break;
+                    if (c === '"')
+                        return fail('quote inside an unquoted field', line, i, lineStart);
+                    i++;
+                }
+                field = text.slice(s, i);
+            }
+            row.fields.push(field);
+            if (i >= n)
+                break;
+            if (text[i] === delim) {
+                i++;
+                continue;
+            }
+            // Record terminator.
+            i += text[i] === '\r' ? 2 : 1;
+            line++;
+            lineStart = i;
+            break;
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+//# sourceMappingURL=csv.js.map

package/lib/src/deflate.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Deterministic DEFLATE (RFC 1951) and gzip (RFC 1952) encoder.
+ *
+ * `rust/src/deflate.rs` implements the same algorithm and must produce the same
+ * bytes for every input, so that archives and OCI layers (and therefore image
+ * IDs) are identical between the two implementations. Any change here must be
+ * made in both files, and the differential fixtures regenerated
+ * (`node rust/tests/fixtures/deflate/generate.mjs`). Decompression is not
+ * affected: any inflater reads this output.
+ *
+ * Specification (every choice below is part of the output format):
+ *
+ * LZ77 matching
+ *  - Window 32768 bytes; matches are 3..258 bytes at distance 1..32768.
+ *  - Hash of position p (only when p + 3 <= n): x = d[p] << 16 | d[p+1] << 8 | d[p+2];
+ *    h = (x * 0x9E3779B1 mod 2^32) >> 17 (15 bits). `head[h]` holds the most
+ *    recent inserted position with that hash, `prev[p & 32767]` the position
+ *    that was in `head[h]` when p was inserted (-1 = none).
+ *  - findMatch(p): if p + 3 > n, no match. Otherwise walk the chain starting
+ *    at head[h(p)]: candidate c is considered while c >= 0, p - c <= 32768 and
+ *    fewer than MAX_CHAIN (64) candidates have been considered; the next
+ *    candidate is prev[c & 32767], and the walk stops if that is not < c.
+ *    For each candidate, len = length of the common prefix of d[c..] and
+ *    d[p..], at most min(258, n - p). A candidate replaces the best only if
+ *    len > bestLen (so on ties the nearest wins); the walk stops once
+ *    bestLen >= 258 (or reaches min(258, n - p)). Then p is inserted.
+ *    A best match of length 3 at distance > 4096 is dropped (no match).
+ *  - Every position p with p + 3 <= n is inserted exactly once, in increasing
+ *    order, before findMatch is called for any later position.
+ *  - Parsing (lazy, one position at a time): at p, m = findMatch(p). If
+ *    m.len < 3: literal d[p], p += 1. Otherwise, while m.len < LAZY_LIMIT (16)
+ *    and p + 1 < n: m2 = findMatch(p + 1), searching at most MAX_CHAIN / 4 (16)
+ *    candidates when m.len >= GOOD_LENGTH (8); if m2.len > m.len, emit literal
+ *    d[p], p += 1, m = m2 and repeat; else stop. Then emit match m at p, insert
+ *    the positions up to p + m.len - 1 that are not yet inserted, p += m.len.
+ *
+ * Blocks
+ *  - Symbols (literals and length/distance pairs) are buffered. At the start
+ *    of each parsing step (p < n), if the buffer holds >= BLOCK_SYMBOLS (16384)
+ *    symbols it is written as a non-final block. When the input is exhausted
+ *    the remaining symbols (none only for empty input) are written as the
+ *    final block (BFINAL = 1).
+ *  - Each block is written as whichever of stored, fixed Huffman or dynamic
+ *    Huffman takes the fewest bits, given the current bit position; on a tie
+ *    the earlier of stored, fixed, dynamic wins. Stored is a candidate only
+ *    when the block covers <= 65535 input bytes; its cost is 3 header bits,
+ *    padding to a byte boundary, 32 bits of LEN/NLEN and 8 bits per byte.
+ *  - Huffman code lengths (literal/length tree max 15 bits, distance tree max
+ *    15, code-length tree max 7) come from package-merge: leaves are the
+ *    symbols with nonzero frequency sorted by (frequency, symbol); L - 1 times,
+ *    pair consecutive items of the previous list (dropping an odd last item)
+ *    into packages and merge them with the leaves by weight, a leaf before a
+ *    package on equal weight; a symbol's length is the number of times it
+ *    occurs in the first 2k - 2 items of the final list (k = leaf count). If
+ *    fewer than two symbols are used, the used one (if any) and the lowest
+ *    unused symbols are added until there are two, each with length 1.
+ *    Codes are canonical (RFC 1951 3.2.2).
+ *  - Dynamic header: HLIT = max(257, last used literal/length symbol + 1),
+ *    HDIST = max(1, last used distance symbol + 1) (an unused tree still has
+ *    two length-1 codes, so this is at least 2); HCLEN = max(4, last nonzero
+ *    entry in the order 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 + 1).
+ *    The HLIT + HDIST lengths form one sequence, run-length coded left to
+ *    right: for value v with run r of equal values starting here, if v = 0:
+ *    r >= 11 → 18 (min(r, 138)), r >= 3 → 17 (r), else a single 0; if v != 0:
+ *    emit v once, then while the rest of the run is >= 3, 16 (min(rest, 6)).
+ *
+ * gzip: header 1f 8b 08, FLG 0, MTIME 0, XFL 0, OS 3 (Unix), then the raw
+ * deflate stream, CRC-32 and ISIZE (little-endian).
+ */
+/** Package-merge length-limited Huffman code lengths. */
+export declare function codeLengths(freq: ArrayLike<number>, maxBits: number): Uint8Array;
+/** Raw DEFLATE stream (zip method 8). */
+export declare function deflateRaw(data: Uint8Array): Uint8Array;
+export declare function crc32(data: Uint8Array): number;
+/** gzip member with a fixed header (no mtime, no name, XFL 0, OS 3). */
+export declare function gzip(data: Uint8Array): Uint8Array;