@deckbuilderkit/editor 0.0.0-stage → 0.1.0

package/src/sql/statements.ts

@@ -0,0 +1,83 @@
+import { tokenize, type Token } from './tokens.ts';
+
+export interface Statement {
+  from: number;
+  to: number;
+  text: string;
+}
+
+const TRIVIA = new Set(['whitespace', 'newline', 'lineComment', 'blockComment']);
+const CREATE_SKIP = new Set(['or', 'replace', 'editionable', 'noneditionable']);
+const CREATE_PLSQL = new Set(['procedure', 'function', 'package', 'trigger']);
+
+function words(tokens: Token[], start: number, max: number): string[] {
+  const out: string[] = [];
+  for (let i = start; i < tokens.length && out.length < max; i++) {
+    const t = tokens[i]!;
+    if (TRIVIA.has(t.kind)) continue;
+    if (t.kind !== 'keyword' && t.kind !== 'identifier') break;
+    out.push(t.text.toLowerCase());
+  }
+  return out;
+}
+
+export function isPlsqlStart(tokens: Token[], start: number): boolean {
+  const w = words(tokens, start, 8);
+  if (w[0] === 'begin' || w[0] === 'declare') return true;
+  if (w[0] !== 'create') return false;
+  let i = 1;
+  while (i < w.length && CREATE_SKIP.has(w[i]!)) i++;
+  const kind = w[i];
+  if (kind === undefined) return false;
+  if (CREATE_PLSQL.has(kind)) return true;
+  return kind === 'type' && w[i + 1] === 'body';
+}
+
+export function splitStatements(text: string): Statement[] {
+  const tokens = tokenize(text);
+  const out: Statement[] = [];
+  let start = 0;
+  let started = false;
+  let plsql = false;
+
+  const push = (to: number): void => {
+    if (started) {
+      const raw = text.slice(start, to);
+      const lead = raw.length - raw.trimStart().length;
+      const trimmed = raw.trim();
+      if (trimmed) out.push({ from: start + lead, to: start + lead + trimmed.length, text: trimmed });
+    }
+    started = false;
+    plsql = false;
+  };
+
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i]!;
+    if (t.kind === 'slash') {
+      push(t.from);
+      start = t.to;
+      continue;
+    }
+    if (TRIVIA.has(t.kind)) continue;
+    if (!started) {
+      started = true;
+      plsql = isPlsqlStart(tokens, i);
+    }
+    if (t.kind === 'punctuation' && t.text === ';' && !plsql) {
+      push(t.from);
+      start = t.to;
+    }
+  }
+  push(text.length);
+  return out;
+}
+
+export function statementAt(text: string, offset: number): Statement | undefined {
+  const statements = splitStatements(text);
+  let before: Statement | undefined;
+  for (const s of statements) {
+    if (offset >= s.from && offset <= s.to) return s;
+    if (s.to < offset) before = s;
+  }
+  return before ?? statements[0];
+}

package/src/sql/tokens.ts

@@ -0,0 +1,156 @@
+import { PLSQL } from '@codemirror/lang-sql';
+
+export type TokenKind =
+  | 'keyword'
+  | 'identifier'
+  | 'quotedIdentifier'
+  | 'string'
+  | 'qquote'
+  | 'number'
+  | 'operator'
+  | 'punctuation'
+  | 'bind'
+  | 'lineComment'
+  | 'blockComment'
+  | 'whitespace'
+  | 'newline'
+  | 'slash';
+
+export interface Token {
+  kind: TokenKind;
+  from: number;
+  to: number;
+  text: string;
+}
+
+export const SQL_KEYWORDS: ReadonlySet<string> = new Set(
+  (PLSQL.spec.keywords ?? '').split(/\s+/).filter(Boolean).map((k) => k.toLowerCase()),
+);
+
+const CLOSERS: Record<string, string> = { '[': ']', '{': '}', '(': ')', '<': '>' };
+const OPERATORS = ['||', '<=', '>=', '<>', '!=', '^=', '~=', ':=', '=>', '..', '**', '<<', '>>'];
+const SINGLE_OPERATORS = '+-*/=<>!^~%|:';
+const PUNCTUATION = '(),;.[]{}@';
+
+const isIdentStart = (c: string): boolean => /[\p{L}_]/u.test(c);
+const isIdentPart = (c: string): boolean => /[\p{L}\p{N}_$#]/u.test(c);
+const isDigit = (c: string | undefined): boolean => c !== undefined && c >= '0' && c <= '9';
+const isBlank = (c: string): boolean => c === ' ' || c === '\t' || c === '\f' || c === '\v';
+
+function quoted(text: string, start: number, quote: string): number {
+  let i = start + 1;
+  while (i < text.length) {
+    if (text[i] === quote) {
+      if (text[i + 1] === quote) {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return text.length;
+}
+
+function qQuoteEnd(text: string, quoteAt: number): number {
+  const open = text[quoteAt + 1]!;
+  const close = CLOSERS[open] ?? open;
+  const end = text.indexOf(close + "'", quoteAt + 2);
+  return end < 0 ? text.length : end + 2;
+}
+
+function isOwnLine(text: string, i: number): boolean {
+  for (let j = i - 1; j >= 0 && text[j] !== '\n'; j--) if (!isBlank(text[j]!) && text[j] !== '\r') return false;
+  for (let j = i + 1; j < text.length && text[j] !== '\n'; j++) if (!isBlank(text[j]!) && text[j] !== '\r') return false;
+  return true;
+}
+
+function numberEnd(text: string, start: number): number {
+  let i = start;
+  while (isDigit(text[i])) i++;
+  if (text[i] === '.' && text[i + 1] !== '.') {
+    i++;
+    while (isDigit(text[i])) i++;
+  }
+  if (text[i] === 'e' || text[i] === 'E') {
+    let j = i + 1;
+    if (text[j] === '+' || text[j] === '-') j++;
+    if (isDigit(text[j])) {
+      while (isDigit(text[j])) j++;
+      i = j;
+    }
+  }
+  return i;
+}
+
+export function tokenize(text: string): Token[] {
+  const tokens: Token[] = [];
+  const n = text.length;
+  let i = 0;
+  while (i < n) {
+    const c = text[i]!;
+    const next = text[i + 1];
+    let kind: TokenKind;
+    let end: number;
+    if (c === '\n' || (c === '\r' && next === '\n')) {
+      kind = 'newline';
+      end = c === '\r' ? i + 2 : i + 1;
+    } else if (isBlank(c) || c === '\r') {
+      kind = 'whitespace';
+      end = i + 1;
+      while (end < n && (isBlank(text[end]!) || (text[end] === '\r' && text[end + 1] !== '\n'))) end++;
+    } else if (c === '-' && next === '-') {
+      kind = 'lineComment';
+      end = i + 2;
+      while (end < n && text[end] !== '\n' && !(text[end] === '\r' && text[end + 1] === '\n')) end++;
+    } else if (c === '/' && next === '*') {
+      kind = 'blockComment';
+      const close = text.indexOf('*/', i + 2);
+      end = close < 0 ? n : close + 2;
+    } else if (c === '/' && isOwnLine(text, i)) {
+      kind = 'slash';
+      end = i + 1;
+    } else if (c === "'") {
+      kind = 'string';
+      end = quoted(text, i, "'");
+    } else if (c === '"') {
+      kind = 'quotedIdentifier';
+      end = quoted(text, i, '"');
+    } else if (isDigit(c) || (c === '.' && isDigit(next))) {
+      kind = 'number';
+      end = numberEnd(text, i);
+    } else if (isIdentStart(c)) {
+      end = i + 1;
+      while (end < n && isIdentPart(text[end]!)) end++;
+      const lower = text.slice(i, end).toLowerCase();
+      if ((lower === 'q' || lower === 'nq') && text[end] === "'" && end + 1 < n && !/\s/.test(text[end + 1]!)) {
+        kind = 'qquote';
+        end = qQuoteEnd(text, end);
+      } else if (lower === 'n' && text[end] === "'") {
+        kind = 'string';
+        end = quoted(text, end, "'");
+      } else {
+        kind = SQL_KEYWORDS.has(lower) ? 'keyword' : 'identifier';
+      }
+    } else if (c === ':' && next !== undefined && isIdentPart(next)) {
+      kind = 'bind';
+      end = i + 2;
+      while (end < n && isIdentPart(text[end]!)) end++;
+    } else if (OPERATORS.includes(c + (next ?? ''))) {
+      kind = 'operator';
+      end = i + 2;
+    } else if (SINGLE_OPERATORS.includes(c)) {
+      kind = 'operator';
+      end = i + 1;
+    } else if (PUNCTUATION.includes(c)) {
+      kind = 'punctuation';
+      end = i + 1;
+    } else {
+      kind = 'operator';
+      end = i + 1;
+    }
+    tokens.push({ kind, from: i, to: end, text: text.slice(i, end) });
+    i = end;
+  }
+  return tokens;
+}

package/src/sql/xmlQuery.ts

@@ -0,0 +1,249 @@
+/** SQL inside Miles query files: `<queries><query name=".."><statement><![CDATA[ SQL ]]></statement></query></queries>`. */
+
+export interface XmlQueryStatement {
+  /** Position among the file's statements. */
+  index: number;
+  /** `name` attribute of the enclosing `<query>` ('' when none). */
+  name: string;
+  /** `set-name` attribute of the enclosing `<query>` ('' when none). */
+  setName: string;
+  /** Display label: name, set-name or `#n`. */
+  label: string;
+  /** The SQL to edit (prefix text + CDATA content, or unescaped text). */
+  sql: string;
+  /** Range of the file text that `sql` stands for; `spliceXmlStatement` replaces exactly this. */
+  from: number;
+  to: number;
+  /** True when the statement holds a CDATA section. */
+  cdata: boolean;
+  /** Non-blank text before the first CDATA section (already part of `sql`); '' otherwise. */
+  prefix: string;
+}
+
+export interface XmlQueries {
+  statements: XmlQueryStatement[];
+}
+
+const ESCAPES: [RegExp, string][] = [[/&lt;/g, '<'], [/&gt;/g, '>'], [/&quot;/g, '"'], [/&apos;/g, "'"], [/&amp;/g, '&']];
+
+export function unescapeXml(s: string): string {
+  let out = s;
+  for (const [re, ch] of ESCAPES) out = out.replace(re, ch);
+  return out;
+}
+
+export function escapeXml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+const blank = (m: string) => m.replace(/[^\r\n]/g, ' ');
+
+/** Same length as `text`, with comments and CDATA bodies blanked so tag searches cannot hit them. */
+function mask(text: string): string {
+  return text.replace(/<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>/g, (m) => (m.startsWith('<!--') ? blank(m) : `<![CDATA[${blank(m.slice(9, -3))}]]>`));
+}
+
+function attr(tag: string, key: string): string {
+  const m = new RegExp(`\\s${key}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
+  return m ? unescapeXml(m[1] ?? m[2] ?? '') : '';
+}
+
+/** The statements of a `<queries>` file, or null when the root is not `<queries>` or no `<statement>` exists. */
+export function parseXmlQueries(text: string): XmlQueries | null {
+  const masked = mask(text);
+  const root = /^?\s*(?:<\?[\s\S]*?\?>\s*|<!DOCTYPE[^>]*>\s*)*<([A-Za-z_][\w.:-]*)/.exec(masked);
+  if (!root || root[1] !== 'queries') return null;
+  const statements: XmlQueryStatement[] = [];
+  const re = /<statement\b[^>]*?(\/)?>(?:([\s\S]*?)<\/statement\s*>)?/g;
+  for (let m = re.exec(masked); m; m = re.exec(masked)) {
+    if (m[1] || m[2] === undefined) continue;
+    const innerFrom = m.index + m[0].indexOf('>') + 1;
+    const inner = text.slice(innerFrom, innerFrom + m[2].length);
+    const before = masked.slice(0, m.index);
+    const q = before.lastIndexOf('<query');
+    const closed = before.lastIndexOf('</query');
+    let name = '';
+    let setName = '';
+    if (q >= 0 && closed < q && /^<query[\s>]/.test(before.slice(q))) {
+      const tag = before.slice(q, before.indexOf('>', q) + 1);
+      name = attr(tag, 'name');
+      setName = attr(tag, 'set-name');
+    }
+    const index = statements.length;
+    const label = name || setName || `#${index + 1}`;
+    const first = inner.indexOf('<![CDATA[');
+    if (first < 0) {
+      statements.push({ index, name, setName, label, sql: unescapeXml(inner), from: innerFrom, to: innerFrom + inner.length, cdata: false, prefix: '' });
+      continue;
+    }
+    const lastEnd = inner.lastIndexOf(']]>') + 3;
+    const lead = inner.slice(0, first);
+    const keepLead = lead.trim() === '';
+    const start = keepLead ? first : 0;
+    let sql = keepLead ? '' : lead;
+    const cd = /<!\[CDATA\[([\s\S]*?)\]\]>/g;
+    let pos = first;
+    for (let c = cd.exec(inner); c; c = cd.exec(inner)) {
+      sql += inner.slice(pos, c.index) + c[1];
+      pos = c.index + c[0].length;
+    }
+    sql += inner.slice(pos, lastEnd);
+    statements.push({ index, name, setName, label, sql, from: innerFrom + start, to: innerFrom + lastEnd, cdata: true, prefix: keepLead ? '' : lead });
+  }
+  return statements.length > 0 ? { statements } : null;
+}
+
+const cdataOf = (sql: string) => `<![CDATA[${sql.replace(/\]\]>/g, ']]]]><![CDATA[>')}]]>`;
+
+/** Writes edited SQL back into one statement of `text`; every other byte stays. `sql` unchanged returns `text` itself. */
+export function spliceXmlStatement(text: string, st: XmlQueryStatement, sql: string): string {
+  if (sql === st.sql) return text;
+  let body: string;
+  if (!st.cdata) body = escapeXml(sql);
+  else if (st.prefix && sql.startsWith(st.prefix)) body = st.prefix + cdataOf(sql.slice(st.prefix.length));
+  else body = cdataOf(sql);
+  return text.slice(0, st.from) + body + text.slice(st.to);
+}
+
+const SEP_LINE = /^-- ==== (.*) ====[ \t]*\r?$/;
+const labelOf = (st: XmlQueryStatement) => st.label.replace(/\s+/g, ' ');
+const sepOf = (st: XmlQueryStatement) => `-- ==== ${labelOf(st)} ====`;
+
+/** Terminator the statement splitter needs after `sql` ('' when it already ends in `;` or is empty). */
+function suffixFor(sql: string): string {
+  const body = sql.trimEnd();
+  if (!body || body.endsWith(';')) return '';
+  const last = body.slice(body.lastIndexOf('\n') + 1);
+  return last.includes('--') ? '\n;' : ';';
+}
+
+/** One editor value for all statements: a separator comment line per statement, blank line between. One statement: its SQL as is. */
+export function combineXmlStatements(statements: XmlQueryStatement[]): string {
+  if (statements.length === 1) return statements[0]!.sql;
+  return statements
+    .map((st) => {
+      const body = st.sql.trimEnd();
+      return `${sepOf(st)}\n${body}${suffixFor(st.sql)}${st.sql.slice(body.length)}`;
+    })
+    .join('\n\n');
+}
+
+/** Maps an edited combined value back to one SQL per statement. Missing separators leave that statement empty and its text with the previous one. */
+export function splitXmlStatements(statements: XmlQueryStatement[], combined: string): string[] {
+  if (statements.length === 1) return [combined];
+  const segs: string[] = statements.map(() => '');
+  const lines = combined.split('\n');
+  let next = 0;
+  let cur = -1;
+  let pre = '';
+  const add = (line: string, last: boolean) => {
+    const piece = last ? line : `${line}\n`;
+    if (cur < 0) pre += piece;
+    else segs[cur] += piece;
+  };
+  lines.forEach((line, i) => {
+    const m = SEP_LINE.exec(line);
+    const hit = m ? statements.findIndex((st, j) => j >= next && labelOf(st) === m[1]) : -1;
+    if (hit >= 0) {
+      cur = hit;
+      next = hit + 1;
+      return;
+    }
+    add(line, i === lines.length - 1);
+  });
+  segs[0] = pre + segs[0];
+  return statements.map((st, i) => {
+    let seg = segs[i]!;
+    if (i < statements.length - 1) seg = seg.endsWith('\n\n') ? seg.slice(0, -2) : seg.endsWith('\n') ? seg.slice(0, -1) : seg;
+    const body = seg.trimEnd();
+    const suffix = suffixFor(st.sql);
+    return (suffix && body.endsWith(suffix) ? body.slice(0, -suffix.length) : body) + seg.slice(body.length);
+  });
+}
+
+/** Writes an edited combined value back into `text`; unchanged statements keep their bytes, an unchanged value returns `text` itself. */
+export function applyCombinedXml(text: string, statements: XmlQueryStatement[], combined: string): string {
+  const sqls = splitXmlStatements(statements, combined);
+  let out = text;
+  for (let i = statements.length - 1; i >= 0; i--) out = spliceXmlStatement(out, statements[i]!, sqls[i]!);
+  return out;
+}
+
+/** Blanks comments and string literals (same length) so structure scans ignore them. */
+function blankSql(sql: string): string {
+  return sql.replace(/--[^\n]*|\/\*[\s\S]*?\*\/|'(?:[^']|'')*'/g, blank);
+}
+
+/** Names exposed by the outermost select list (aliases or plain column names, lower-cased). Unsure items are skipped. */
+function selectNames(sql: string): Set<string> {
+  const s = blankSql(sql);
+  const names = new Set<string>();
+  const sel = /\bselect\b/i.exec(s);
+  if (!sel) return names;
+  let depth = 0;
+  let start = sel.index + sel[0].length;
+  const items: string[] = [];
+  let end = s.length;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i]!;
+    if (c === '(') depth++;
+    else if (c === ')') {
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+      depth--;
+    } else if (depth === 0 && c === ',') {
+      items.push(s.slice(start, i));
+      start = i + 1;
+    } else if (depth === 0 && /\s/.test(s[i - 1] ?? ' ') && /^from\b/i.test(s.slice(i))) {
+      end = i;
+      break;
+    }
+  }
+  items.push(s.slice(start, end));
+  for (const raw of items) {
+    const item = raw.replace(/^\s*(?:distinct|unique|all)\s+/i, '').trim();
+    if (!item || item.endsWith('*')) continue;
+    const q = /(?:\s|\)|^)"([^"]+)"$/.exec(item);
+    if (q) {
+      names.add(q[1]!.toLowerCase());
+      continue;
+    }
+    const plain = /^(?:[A-Za-z_][\w$#]*\.)*([A-Za-z_][\w$#]*)$/.exec(item);
+    if (plain) {
+      names.add(plain[1]!.toLowerCase());
+      continue;
+    }
+    const alias = /[\s)"'\w]\s+(?:as\s+)?([A-Za-z_][\w$#]*)$/i.exec(item);
+    if (alias && !/[+\-*/|<>=]\s*$/.test(item.slice(0, item.length - alias[1]!.length).trimEnd())) names.add(alias[1]!.toLowerCase());
+  }
+  return names;
+}
+
+const PLACEHOLDER = /\{([A-Za-z_]\w*)\}/g;
+
+/**
+ * One SQL from chained Miles queries: `{name}` in a later statement becomes a scalar subquery of the nearest earlier statement
+ * whose select list exposes `name`. Numeric `{0}` parameters and unresolved names stay. The result is the last statement, earlier ones inlined.
+ */
+export function mergeXmlStatements(statements: XmlQueryStatement[]): string {
+  const merged: string[] = [];
+  const names = statements.map((st) => selectNames(st.sql));
+  statements.forEach((st, i) => {
+    merged.push(
+      st.sql.replace(PLACEHOLDER, (all, name: string) => {
+        for (let j = i - 1; j >= 0; j--) {
+          if (!names[j]!.has(name.toLowerCase())) continue;
+          const inner = merged[j]!.trimEnd().replace(/\s*;+$/, '');
+          const lastLine = inner.slice(inner.lastIndexOf('\n') + 1);
+          const close = lastLine.includes('--') ? '\n' : '';
+          return `(SELECT ${name} FROM (${inner}${close}) WHERE ROWNUM = 1)`;
+        }
+        return all;
+      }),
+    );
+  });
+  const header = `-- merged from: ${statements.map(labelOf).join(', ')}`;
+  return `${header}\n${(merged[merged.length - 1] ?? '').trim()}`;
+}

package/src/sqlProblems.ts

@@ -0,0 +1,40 @@
+import { t } from '@deckbuilderkit/ui';
+import type { SqlLintSeverity, SqlProblem } from './sql/lint';
+
+/** Most severe first. */
+export const SQL_SEVERITIES: readonly SqlLintSeverity[] = ['error', 'warning', 'info'];
+
+/** The localized message of a lint problem (`sqlLint.<code>` with its params). */
+export function sqlProblemMessage(p: SqlProblem): string {
+  return t(`sqlLint.${p.code}`, p.params);
+}
+
+/** The worst severity among the problems, or undefined when there are none. */
+export function worstSeverity(problems: readonly SqlProblem[]): SqlLintSeverity | undefined {
+  let worst: SqlLintSeverity | undefined;
+  for (const p of problems) {
+    if (p.severity === 'error') return 'error';
+    if (p.severity === 'warning') worst = 'warning';
+    else if (!worst) worst = 'info';
+  }
+  return worst;
+}
+
+/** Offsets where each line starts, for offset → line lookups. */
+export function lineStarts(text: string): number[] {
+  const starts = [0];
+  for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1)) starts.push(i + 1);
+  return starts;
+}
+
+/** 1-based line of an offset. */
+export function lineOf(starts: readonly number[], offset: number): number {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (starts[mid]! <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo + 1;
+}

package/src/table.ts

@@ -0,0 +1,89 @@
+/** Splits delimited text (RFC 4180: quoted fields may hold the delimiter, quotes and line breaks). */
+export function parseDelimited(text: string, delimiter: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    if (quoted) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else quoted = false;
+      } else field += ch;
+    } else if (ch === '"' && field === '') quoted = true;
+    else if (ch === delimiter) {
+      row.push(field);
+      field = '';
+    } else if (ch === '\n' || ch === '\r') {
+      if (ch === '\r' && text[i + 1] === '\n') i++;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = '';
+    } else field += ch;
+  }
+  if (field !== '' || row.length) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+
+/** The delimiter of a `.tsv` file is a tab; a `.csv` one is `;` when the first line has more of them than commas. */
+export function delimiterOf(name: string, text: string): string {
+  if (/\.tsv$/i.test(name)) return '\t';
+  const first = text.slice(0, text.search(/\r|\n|$/));
+  const count = (ch: string) => first.split(ch).length - 1;
+  return count(';') > count(',') ? ';' : ',';
+}
+
+/** Orders cells as numbers when both are numeric, else as text. */
+export function compareCells(a: string, b: string): number {
+  const x = Number(a);
+  const y = Number(b);
+  if (a.trim() !== '' && b.trim() !== '' && !Number.isNaN(x) && !Number.isNaN(y)) return x - y;
+  return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+}
+
+const MASKED_KEY = /^\s*(?:export\s+)?([A-Za-z_][\w.-]*)\s*=\s*(.*)$/;
+
+export interface EnvLine {
+  /** The variable name, or null for a comment or blank line. */
+  key: string | null;
+  value: string;
+  /** The text of a comment or blank line. */
+  raw: string;
+}
+
+/** Reads `KEY=value` lines of a `.env` file; quotes around a value are dropped. */
+export function parseEnv(text: string): EnvLine[] {
+  return text.split(/\r?\n/).map((raw) => {
+    const m = MASKED_KEY.exec(raw);
+    if (!m || raw.trimStart().startsWith('#')) return { key: null, value: '', raw };
+    let value = m[2]!.trim();
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.endsWith(value[0]!)) value = value.slice(1, -1);
+    return { key: m[1]!, value, raw };
+  });
+}
+
+/** One hex-dump row per 16 bytes: offset, hex pairs and printable characters. */
+export function hexRows(bytes: Uint8Array): { offset: string; hex: string; ascii: string }[] {
+  const rows: { offset: string; hex: string; ascii: string }[] = [];
+  for (let at = 0; at < bytes.length; at += 16) {
+    const chunk = bytes.subarray(at, at + 16);
+    let hex = '';
+    let ascii = '';
+    for (let i = 0; i < 16; i++) {
+      if (i < chunk.length) {
+        const b = chunk[i]!;
+        hex += b.toString(16).padStart(2, '0') + (i === 7 ? '  ' : ' ');
+        ascii += b >= 32 && b < 127 ? String.fromCharCode(b) : '.';
+      } else hex += i === 7 ? '    ' : '   ';
+    }
+    rows.push({ offset: at.toString(16).padStart(8, '0'), hex, ascii });
+  }
+  return rows;
+}

package/src/text-save.ts

@@ -0,0 +1,28 @@
+export type Eol = '\n' | '\r\n';
+
+/** The line break most lines of `text` end with; `fallback` when it has none. */
+export function detectEol(text: string, fallback: Eol = '\n'): Eol {
+  const crlf = text.split('\r\n').length - 1;
+  const lf = text.split('\n').length - 1 - crlf;
+  if (crlf === 0 && lf === 0) return fallback;
+  return crlf > lf ? '\r\n' : '\n';
+}
+
+/** `text` with every line break as `\n`, as the editor holds it. */
+export const normalizeEol = (text: string) => text.replace(/\r\n?/g, '\n');
+
+/** Editor text (`\n` breaks) with `eol` breaks, for writing. */
+export const applyEol = (text: string, eol: Eol) => (eol === '\n' ? text : text.replace(/\n/g, eol));
+
+/** `text` without spaces and tabs at line ends. */
+export const trimTrailingWhitespace = (text: string) => text.replace(/[ \t]+$/gm, '');
+
+/** `text` ending with one line break; an empty text stays empty. */
+export const ensureFinalNewline = (text: string) => (text === '' || text.endsWith('\n') ? text : `${text}\n`);
+
+/** The save-time edits of VS Code's `files.trimTrailingWhitespace` and `files.insertFinalNewline`. */
+export function prepareForSave(text: string, opts: { trim: boolean; finalNewline: boolean; markdown: boolean }): string {
+  let out = opts.trim && !opts.markdown ? trimTrailingWhitespace(text) : text;
+  if (opts.finalNewline) out = ensureFinalNewline(out);
+  return out;
+}