@chalky/chalky 0.1.5 → 0.1.6

package/server.ts

@@ -5,6 +5,7 @@
 //   - keeps one pi AgentSession per agent (session name = agent name; saved under data/sessions/<agent>);
 //   - keeps the rule for the version history (host.history) and serves /recover, going back to a working version
 //     when an agent broke the page (the safety net);
+//   - brings a new release of this package into the home's agent/, merged with what the agents changed (host.update);
 //   - hands each agent's pi events to the extensions that asked (host.eventHandlers), and tells them when a page
 //     opens (host.connectHandlers). The page extension turns pi's messages into the page's and replays them.
 // Extensions reach the host through globalThis.chalky (pi loads them with jiti, so they don't share our imports).
@@ -17,6 +18,7 @@ import path from "node:path";
 import { createAgentSession, createCodemodeExtension, createMcpExtension, createToolSearchExtension, DefaultResourceLoader, SessionManager,
   SettingsManager } from "@earendil-works/pi-coding-agent";
 import git from "isomorphic-git";
+import diff3Merge from "diff3";
 import { WebSocketServer } from "ws";
 
 const ROOT = import.meta.dirname;                         // this package: server.ts and the starting agent/
@@ -97,9 +99,9 @@ function migrate() {
       .replaceAll("/ui/agents.js", "/app/agents.js").replaceAll("/ui/voice.js", "/voice/voice.js")
       .replaceAll("/ui-api/app-data/", "/app/data/").replaceAll("/ui/apps/", "/built/apps/"));
 }
-migrate();
-if (!fs.existsSync(AGENT)) startAgent();  // first run: the starting agent
+migrate();  // (a new home's agent/ comes from the update below: the first release, merged into nothing)
 if (HOME !== ROOT) {  // HOME/agent's extensions import our dependencies: Node looks for a node_modules above them
+  fs.mkdirSync(HOME, { recursive: true });  // a new home: nothing made it yet
   const link = path.join(HOME, "node_modules");
   if (fs.lstatSync(link, { throwIfNoEntry: false })?.isSymbolicLink()) fs.unlinkSync(link);  // again each start: the package may have moved
   if (fs.existsSync(link)) throw new Error(`${link} is in the way: Chalky links it to ${MODULES}`);
@@ -266,19 +268,174 @@ function file(res: http.ServerResponse, p: string) {
 // The version extension commits and rolls back with this; /recover too, so it works when that extension is broken.
 //   repo     isomorphic-git's {fs, dir: HOME, gitdir}
 //   stage()  git add -A for what inHistory keeps (.gitignore files play no part); returns the changed paths
+//   restore(oid)  that version's agent/ and built/ into the folders and the index, removing files it doesn't have
+//            (the branch stays where it is; what the history doesn't keep, logins and endpoints, isn't touched)
+//   versions()  the user's versions, newest first, as git.log gives them ({oid, commit}): main's own line, without
+//            the releases an update merged in (see "updates" below)
 const REPO = { fs, dir: HOME, gitdir: path.join(DATA, "version", "git") };
 const KEPT = { filepaths: ["agent", "built"], ignored: true, filter: inHistory };  // statusMatrix's walk: only these
+// isomorphic-git 1.44.2 takes a file whose size and mtime (whole seconds) match the index as unchanged: a same-size
+// change in the second after it was staged would be missed (and an update would write over it). Real git checks
+// those "racy" files; here every file that looks unchanged is checked by its content. Its status also misses a change
+// of the x bit alone: checked too.
 async function stage() {
-  const changed = [];
+  const changed = [], staged = new Map<string, string>();  // the index: path -> "oid mode"
+  await git.walk({ ...REPO, trees: [git.STAGE()], map: async (f, [e]) => {
+    if (e && f !== "." && (await e.type()) === "blob") staged.set(f, `${await e.oid()} ${await e.mode()}`);
+    return true;
+  } });
+  const now = async (f: string) => { const p = path.join(HOME, f);  // the file as git would stage it
+    return `${(await git.hashBlob({ object: fs.readFileSync(p) })).oid} ${fs.statSync(p).mode & 0o111 ? 0o100755 : 0o100644}`; };
   for (const [filepath, head, workdir, index] of await git.statusMatrix({ ...REPO, ...KEPT })) {
-    if (head === 1 && workdir === 1 && index === 1) continue;  // unchanged
+    if (head === 1 && workdir === 1 && index === 1 && await now(filepath) === staged.get(filepath)) continue;  // unchanged
     if (workdir === 0) { if (index !== 0) await git.remove({ ...REPO, filepath }); }
     else await git.add({ ...REPO, filepath, force: true });
     changed.push(filepath);
   }
   return changed;
 }
-Object.assign(host, { history: { repo: REPO, kept: KEPT, stage } });
+// Only the folders that either version has files in: for a folder neither has (built/ before anything was made, still
+// on disk as built/apps/), isomorphic-git 1.44.2's checkout takes it for a file to delete and throws EISDIR.
+async function restore(oid: string) {
+  const has = async (ref: string, dir: string) => (await git.listFiles({ ...REPO, ref })).some((f) => f.startsWith(`${dir}/`));
+  const head = await git.resolveRef({ ...REPO, ref: "HEAD" });
+  const filepaths = [];
+  for (const dir of KEPT.filepaths) if (await has(oid, dir) || await has(head, dir)) filepaths.push(dir);
+  if (filepaths.length) await git.checkout({ ...REPO, ref: oid, noUpdateHead: true, force: true, filepaths });
+}
+Object.assign(host, { history: { repo: REPO, kept: KEPT, stage, restore } });
+
+// ---- updates: each release of this package is a commit on the history's "package" branch, merged into main ----
+// The package's agent/ is a release; the home's agent/ is what runs, and the agents change it. At start, a release
+// not merged yet is committed on "package" (its agent/ only) and merged into main, file by file. The base is the
+// release merged last (git's merge base), so for each file:
+//   only the release changed it -> the release's        only the home changed it -> the home's
+//   both, in different lines -> both changes (diff3)
+//   both, in the same lines, or one side deleted it -> the home's stays; the release's goes next to it as
+//   <file>.new, and agent1 is asked to merge them (host.update.conflicts)
+// First a "Before update" commit of unsaved changes, then one commit with both parents: the version panel undoes an
+// update like any change. A new home is the first release merged into nothing; a home from before this has no
+// "package" yet: its base is its "original" version (the release it started from). If the update fails, the home
+// runs as it was and the page says why (host.update.error). Not when the home is this folder (node server.ts here).
+// agent/mcp.json is the user's own list of MCP servers: the package never ships it, so no release brings or removes it.
+const RELEASE = `Chalky ${JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf8")).version}`;
+const CHALKY = { name: "chalky", email: "chalky@chalky" };
+const OWN = ["agent/mcp.json"];
+const ref = (r: string) => git.resolveRef({ ...REPO, ref: r }).catch(() => undefined);
+const blob = async (oid: string) => Buffer.from((await git.readBlob({ ...REPO, oid })).blob);
+
+// The user's versions: from HEAD by first parents only (an update's first parent is the version before it; its
+// second, the release), stopping at a release (a new home's first version comes after one). Not git.log: it walks
+// both parents, so the releases would be listed as versions (going back to one would take the agents' changes and
+// built/ away), the first release twice, and versions made in the same second out of order.
+async function versions() {
+  const releases = new Set<string>(), original = await ref("refs/tags/original");  // a home from before: its "original" isn't one
+  for (let oid = await ref("package"); oid && oid !== original; oid = (await git.readCommit({ ...REPO, oid })).commit.parent[0])
+    releases.add(oid);
+  const out = [];
+  for (let oid = await ref("HEAD"); oid && !releases.has(oid); ) {
+    const c = await git.readCommit({ ...REPO, oid });
+    out.push(c);
+    oid = c.commit.parent[0];
+  }
+  return out;
+}
+Object.assign(host.history, { versions });
+
+async function releaseTree(dir: string): Promise<string | null> {  // the package's agent/ (what startAgent copies) as a git tree
+  const tree = [];
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    const rel = path.relative(path.join(ROOT, "agent"), p);
+    if (!isAgentPart(rel) || OWN.includes(`agent/${rel}`)) continue;
+    if (e.isFile()) tree.push({ mode: fs.statSync(p).mode & 0o111 ? "100755" : "100644", path: e.name, type: "blob" as const,
+      oid: await git.writeBlob({ ...REPO, blob: fs.readFileSync(p) }) });
+    else if (e.isDirectory()) { const oid = await releaseTree(p); if (oid) tree.push({ mode: "040000", path: e.name, type: "tree" as const, oid }); }
+  }
+  return tree.length ? git.writeTree({ ...REPO, tree }) : null;
+}
+
+async function filesOf(commit?: string) {  // agent/'s files in a commit: path -> {oid, mode}
+  const files = new Map<string, { oid: string; mode: number }>();
+  if (commit) await git.walk({ ...REPO, trees: [git.TREE({ ref: commit })], map: async (p, [e]) => {
+    if (p !== "." && p !== "agent" && !p.startsWith("agent/")) return null;  // built/: not the release's
+    if (e && (await e.type()) === "blob") files.set(p, { oid: await e.oid(), mode: await e.mode() });
+    return true;
+  } });
+  return files;
+}
+
+function merge3(base: Buffer, ours: Buffer, theirs: Buffer) {  // both changes, or null if they touch the same lines
+  if ([base, ours, theirs].some((b) => b.includes(0))) return null;  // not text
+  const lines = (b: Buffer) => b.toString("utf8").match(/^.*(\r?\n|$)/gm) ?? [];
+  const parts = diff3Merge(lines(ours), lines(base), lines(theirs));
+  return parts.some((p: any) => p.conflict) ? null : parts.flatMap((p: any) => p.ok).join("");
+}
+
+async function update() {
+  let main = await ref("main"), pkg = await ref("package");
+  const last = pkg && (await git.readCommit({ ...REPO, oid: pkg })).commit.message.trim();
+  if (last === RELEASE && main && (await git.findMergeBase({ ...REPO, oids: [main, pkg!] }))[0] === pkg) return;  // merged
+  await git.init({ ...REPO, defaultBranch: "main" });  // (does nothing if there is one)
+  if ((await stage()).length) main = await git.commit({ ...REPO, message: `Before update to ${RELEASE}`, author: CHALKY });
+  if (last !== RELEASE) {
+    const agent = await releaseTree(path.join(ROOT, "agent"));
+    const tree = await git.writeTree({ ...REPO, tree: agent ? [{ mode: "040000", path: "agent", type: "tree", oid: agent }] : [] });
+    const parent = pkg ?? (main && await ref("refs/tags/original"));  // a home from before this: the release it started from
+    pkg = await git.commit({ ...REPO, ref: "refs/heads/package", tree, parent: parent ? [parent] : [], message: RELEASE, author: CHALKY });
+  }
+  const [base] = main ? await git.findMergeBase({ ...REPO, oids: [main, pkg!] }) : [];
+  const [B, O, T] = await Promise.all([base, main, pkg].map(filesOf));
+  const writes: [string, Buffer | null, number?][] = [], conflicts: string[] = [];  // [path in HOME, content (null: delete), mode]
+  for (const f of new Set([...O.keys(), ...T.keys()])) {
+    if (OWN.includes(f)) continue;
+    const [b, o, t] = [B.get(f), O.get(f), T.get(f)], same = (x?: typeof b, y?: typeof b) => x?.oid === y?.oid && x?.mode === y?.mode;
+    if (same(o, t) || same(b, t)) continue;                     // the same, or the release didn't change it: the home's
+    if (same(b, o)) { writes.push([f, t ? await blob(t.oid) : null, t?.mode]); continue; }  // only the release changed it
+    const merged = b && o && t && merge3(await blob(b.oid), await blob(o.oid), await blob(t.oid));  // (and the x bit: whose changed)
+    if (merged != null) { writes.push([f, Buffer.from(merged), b!.mode === t!.mode ? o!.mode : t!.mode]); continue; }
+    if (t) writes.push([`${f}.new`, await blob(t.oid), t.mode]);
+    conflicts.push(!o ? `${f}: you had deleted it; this release changed it (its version: ${f}.new)`
+      : !t ? `${f}: this release removed it; you had changed it (yours is kept)`
+      : `${f}: you and this release changed the same lines (its version: ${f}.new)`);
+  }
+  try {  // (then saved: main moves only when every file is written)
+    for (const [f, content, mode] of writes) {
+      const p = path.join(HOME, f);
+      if (!content) {  // and the folders that leaves empty
+        fs.rmSync(p, { force: true });
+        for (let d = path.dirname(p); d !== AGENT && fs.existsSync(d) && !fs.readdirSync(d).length; d = path.dirname(d)) fs.rmdirSync(d);
+        continue;
+      }
+      fs.mkdirSync(path.dirname(p), { recursive: true });
+      fs.writeFileSync(p, content);
+      if (mode) fs.chmodSync(p, mode & 0o777);
+    }
+    await stage();
+    await git.commit({ ...REPO, message: main ? `Updated to ${RELEASE}` : `Started with ${RELEASE}`, author: CHALKY,
+      parent: main ? [main, pkg!] : [pkg!] });
+  } catch (e) {  // each file written goes back as main has it (contents and x bit), or away (.new files too)
+    for (const [f] of writes) {
+      const p = path.join(HOME, f), o = O.get(f);
+      try {
+        if (!o) { fs.rmSync(p, { force: true }); continue; }
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, await blob(o.oid));
+        fs.chmodSync(p, o.mode & 0o777);
+      } catch (e2) { console.error(`could not put ${f} back:`, e2); }
+    }
+    throw e;
+  }
+  const files = writes.length - writes.filter(([f]) => f.endsWith(".new")).length;
+  if (main) return { release: RELEASE, files, conflicts };  // (a new home: nothing to tell)
+}
+
+if (HOME !== ROOT) try { Object.assign(host, { update: await update() }); } catch (e: any) {  // run as it was: main didn't move
+  console.error(`update to ${RELEASE} failed:`, e);
+  const main = await ref("main");
+  if (main) await restore(main).catch((e) => console.error("could not put agent/ and built/ back as main has them:", e));  // and the index
+  Object.assign(host, { update: { release: RELEASE, error: String(e?.message ?? e) } });
+}
 
 // ---- recovery: the safety net for when an agent breaks the page (or the version extension, so its panel) ----
 // Here, not in an extension, so agents can't break it too. Plain HTML forms, no script: it works whatever agent/ holds.
@@ -292,7 +449,7 @@ const esc = (s: string) => s.replace(/[&<>"]/g, (c) => `&#${c.charCodeAt(0)};`);
 
 async function recoverPage(res: http.ServerResponse) {
   // the history's folder comes before its first commit: right after a start there may be no versions yet
-  const log = fs.existsSync(REPO.gitdir) ? await git.log(REPO).catch((e) => e.code === "NotFoundError" ? [] : Promise.reject(e)) : [];
+  const log = await versions();  // (none yet: [])
   const rows = log.map(({ oid, commit: c }, i) => `<tr><td>${new Date(c.author.timestamp * 1000).toLocaleString()}</td>
     <td>${esc(c.author.name)}</td><td>${esc(c.message.split("\n")[0])}</td>
     <td>${fs.existsSync(path.join(DATA, "version", "shots", `${oid}.png`)) ? "the page worked" : ""}</td>
@@ -315,7 +472,7 @@ async function recover(sha: string, res: http.ServerResponse) {
   const subject = `${sha.slice(0, 7)} ${(await git.readCommit({ ...REPO, oid: sha })).commit.message.split("\n")[0]}`;
   await stage();
   try { await git.commit({ ...REPO, message: "uncommitted changes before recovery", author, disallowEmpty: true }); } catch {}
-  await git.checkout({ ...REPO, ref: sha, noUpdateHead: true, force: true, filepaths: KEPT.filepaths });
+  await restore(sha);
   const files = await stage();
   for (const f of files) for (let d = path.dirname(f); !["agent", "built", "."].includes(d); d = path.dirname(d)) {  // folders it emptied
     try { fs.rmdirSync(path.join(HOME, d)); } catch { break; }
@@ -366,6 +523,11 @@ new WebSocketServer({ server, path: "/ws" }).on("connection", (sock) => {
 
 // agent1, then every agent saved by an earlier run (their conversations come back from their session files)
 await host.createAgent("agent1", "the user's main agent");
+const conflicts: string[] = (host as any).update?.conflicts ?? [];  // the update's files to merge: agent1's task
+if (conflicts.length) host.send("chalky", "agent1", `Chalky was updated to ${(host as any).update.release}. These files `
+  + `were changed both by you (or another agent) and by the update, so yours were kept:\n${conflicts.map((c) => `- ${c}`).join("\n")}\n`
+  + "For each, read both versions and make one that keeps what the user had and adds what the update brings, then "
+  + "delete the .new file. If you can't tell what the user would want, keep theirs and tell them what the update had.");
 for (const name of fs.readdirSync(path.join(DATA, "sessions")).filter((n) => n !== "agent1")) {
   const { role, app } = JSON.parse(fs.readFileSync(path.join(DATA, "sessions", name, "role.json"), "utf8"));
   await host.createAgent(name, role, app);

package/node_modules/xlsx/CHANGELOG.md

@@ -1,361 +0,0 @@
-# CHANGELOG
-
-This log is intended to keep track of backwards-incompatible changes, including
-but not limited to API changes and file location changes.  Minor behavioral
-changes may not be included if they are not expected to break existing code.
-
-## v0.20.3
-
-* Correct parsing of NUMBERS and ODS merge cells (h/t @s-ashwin)
-* More precise treatment of infinite and NaN values
-* XLML Streaming Write
-* Parse `Int8Array` objects (for compatibility with JS engines in Java)
-* CSV Export only quote leading ID (h/t @lako12)
-
-## v0.20.2
-
-* Reworked parsing methods to avoid slow regexes (CVE-2024-22363)
-* HTML properly encode data-v attribute
-* SYLK read and write error cells
-
-## v0.20.1
-
-* `init` use packaged test files to work around GitHub breaking changes
-* SSF date code rounding to 15 decimal digits (h/t @davidtamaki)
-* `sheet_to_json` force UTC interpretation for formatted strings (h/t @Blanay)
-* QPW extract result of string formula
-* XLSX parse non-compliant merge cell expressions
-* NUMBERS correctly handle rows omitted from official exports
-* DBF parse empty logical field (h/t @Roman91)
-* `dense` option added to types
-* package.json add mini and core scripts to export map (h/t @stof)
-
-## v0.20.0
-
-* Use UTC interpretation of Date objects for date cells (potentially breaking)
-* API functions support UTC and local time value interpretations
-* Export `NaN` values to `#NUM!` and infinite values to `#DIV/0!`
-
-## v0.19.3
-
-* XLSX Ensure comment address is valid (h/t @slonser)
-* Enforce Excel worksheet name restrictions
-* Fixed "Prototype Pollution" vulnerability (CVE-2023-30533)
-
-## v0.19.2
-
-* XLSX proper decoding of hyperlinks (h/t @tw-yaxu)
-* XLSX ignore unexpected attributes in rich text (h/t @colin4)
-* `sheet_to_json` type fix (h/t @chsdwn)
-
-## v0.19.1
-
-* Fixed types issue in strict mode (h/t @younes-io)
-* Numbers 12.2 parsing skip ActivityStream.iwa
-
-## v0.19.0
-
-* XLSX export hyperlinks compatible with google sheets (h/t Evan Bovie)
-* NUMBERS export multiple sheets, full worksheet range
-* formalized `dense` mode
-
-## v0.18.12
-
-* `package.json` added types in `exports` structure
-* uncapped NUMBERS single-sheet single-table export
-* DBF export records using supported codepages
-
-## v0.18.11
-
-* Base64 input ignore data URI wrapper
-* Parse ZIP files that use ZIP64 extended information field
-* More precise handling of time-only values
-* Threaded Comment fallback text for older Excel
-
-## v0.18.10
-
-* `exports` field in package.json to satiate ViteJS and newer tooling
-* JSC (Safari / Bun) perf, see <https://bugs.webkit.org/show_bug.cgi?id=243148>
-* workbook `bookType` property to denote the origin format when parsed from file
-* XLSX force export of stub cells with number formats when `sheetStubs` is set
-
-## v0.18.9
-
-* XLSX / ODS write defined names
-* sync defined names to AutoFilter setting on export
-* 1904 date system setting properly roundtripped
-* ODS read/write number formats
-
-## v0.18.8
-
-* Plaintext parsing of dateless meridien time values (`1:23:45 PM`)
-* Legacy format (SYLK / WK# / Multiplan) minutiae
-
-## v0.18.7
-
-* Normalized handling of `\r` and `\n` newline characters
-
-## v0.18.6
-
-* Removed all npm dependencies
-* Auto-correct bad Google Sheets format `d.m`
-* NUMBERS write merge cells, cells up to column "ALL"
-
-## v0.18.5
-
-* Enabled `sideEffects: false` in package.json
-* Basic NUMBERS write support
-
-## v0.18.4
-
-* CSV output omits trailing record separator
-* Properly terminate NodeJS Streams
-* DBF preserve column types on import and use when applicable on export
-
-## v0.18.3
-
-* Removed references to `require` and `process` in browser builds
-
-## v0.18.2
-
-* Hotfix for unicode processing of XLSX exports
-
-## v0.18.1
-
-* Removed Node ESM build script and folded into standard ESM build
-* Removed undocumented aliases including `make_formulae` and `get_formulae`
-
-## v0.18.0
-
-* Browser scripts only expose `XLSX` variable
-* Module no longer ships with `dist/jszip.js` browser script
-
-## v0.17.4
-
-* CLI script moved to `xlsx-cli` package
-
-## v0.17.3
-
-* `window.XLSX` explicit assignment to satiate LWC
-* CSV Proper formatting of errors
-* HTML emit data-\* attributes
-
-## v0.17.2
-
-* Browser and Node optional ESM support
-* DSV correct handling of bare quotes (h/t @bgamrat)
-
-## v0.17.1
-
-* `XLSB` writer uses short cell form when viable
-
-## 0.17.0:
-
-* mini build includes ODS parse/write support
-* DBF explicitly cap worksheet to 1<<20 rows
-* XLS throw errors on truncated records
-
-## v0.16.2
-
-* Disabled `PRN` parsing by default (better support for CSV without delimeters)
-
-## v0.16.1
-
-* skip empty custom property tags if data is absent (fixes DocSecurity issue)
-* HTML output add raw value, type, number format
-* DOM parse look for `v` / `t` / `z` attributes when determining value
-* double quotes in properties escaped using `_x0022_`
-* changed AMD structure for NetSuite and other RequireJS implementations
-- `encode_cell` and `decode_cell` do not rely on `encode_col` / `decode_col`
-
-## v0.16.0
-
-* Date handling changed
-* XLML certain tag tests are now case insensitive
-* Fixed potentially vulnerable regular expressions
-
-## v0.15.6
-
-* CFB prevent infinite loop
-* ODS empty cells marked as stub (type "z")
-* `cellStyles` option implies `sheetStubs`
-
-## v0.15.5
-
-* `sheets` parse option to specify which sheets to parse
-
-## v0.15.4
-
-* AOA utilities properly preserve number formats
-* Number formats captured in stub cells
-
-## v0.15.3
-
-* Properties and Custom Properties properly XML-encoded
-
-## v0.15.2
-
-- `sheet_get_cell` utility function
-- `sheet_to_json` explicitly support `null` as alias for default behavior
-- `encode_col` throw on negative column index
-- HTML properly handle whitespace around tags in a run
-- HTML use `id` option on write
-- Files starting with `0x09` followed by a display character are now TSV files
-- XLS parse references col/row indices mod by the correct number for BIFF ver
-- XLSX comments moved to avoid overlapping cell
-- XLSB outline level
-- AutoFilter update `_FilterDatabase` defined name on write
-- XLML skip CDATA blocks
-
-## v0.15.1 (2019-08-14)
-
-* XLSX ignore XML artifacts
-* HTML capture and persist merges
-
-## v0.15.0
-
-* `dist/xlsx.mini.min.js` mini build with XLSX read/write and some utilities
-* Removed legacy conversion utility functions
-
-## v0.14.5
-
-* XLS PtgNameX lookup
-* XLS always create stub cells for blank cells with comments
-
-
-## v0.14.4
-
-* Better treatment of `skipHidden` in CSV output
-* Ignore CLSID in XLS
-* SYLK 7-bit character encoding
-* SYLK and DBF codepage support
-
-## v0.14.3
-
-* Proper shifting of addresses in Shared Formulae
-
-## v0.14.2
-
-* Proper XML encoding of comments
-
-## v0.14.1
-
-* raw cell objects can be passed to `sheet_add_aoa`
-* `_FilterDatabase` fix for AutoFilter-related crashes
-* `stream.to_json` doesn't end up accidentally scanning to max row
-
-## 0.14.0 (2018-09-06)
-
-* `sheet_to_json` default flipped to `raw: true`
-
-## 0.13.5 (2018-08-25)
-
-* HTML output generates `<br/>` instead of encoded newline character
-
-## 0.13.2 (2018-07-08)
-
-* Buffer.from shim replaced, will not be defined in node `<=0.12`
-
-## 0.13.0 (2018-06-01)
-
-* Library reshaped to support AMD out of the box
-
-## 0.12.11 (2018-04-27)
-
-* XLS/XLSX/XLSB range truncation (errors in `WTF` mode)
-
-## 0.12.4 (2018-03-04)
-
-* `JSZip` renamed to `JSZipSync`
-
-## 0.12.0 (2018-02-08)
-
-* Extendscript target script in NPM package 
-
-## 0.11.19 (2018-02-03)
-
-* Error on empty workbook
-
-## 0.11.16 (2017-12-30)
-
-* XLS ANSI/CP separation
-* 'array' write type and ArrayBuffer processing
-
-## 0.11.6 (2017-10-16)
-
-* Semicolon-delimited files are detected
-
-## 0.11.5 (2017-09-30)
-
-* Bower main script shifted to full version
-* 'binary' / 'string' encoding
-
-## 0.11.3 (2017-08-19)
-
-* XLS cell ixfe/XF removed
-
-## 0.11.0 (2017-07-31)
-
-* Strip `require` statements from minified version
-* minifier mangler enabled
-
-## 0.10.9 (2017-07-28)
-
-* XLML/HTML resolution logic looks further into the data stream to decide type
-* Errors thrown on suspected RTF files
-
-## 0.10.5 (2017-06-09)
-
-* HTML Table output header/footer should not include `<table>` tag
-
-## 0.10.2 (2017-05-16)
-
-* Dates are converted to numbers by default (set `cellDates:true` to emit Dates)
-* Module does not export CFB
-
-## 0.9.10 (2017-04-08)
-
-* `--perf` renamed to `--read-only`
-
-## 0.9.9 (2017-04-03)
-
-* default output format changed to XLSB
-* comment text line endings are now normalized
-* errors thrown on write when worksheets have invalid names
-
-## 0.9.7 (2017-03-28)
-
-* XLS legacy `!range` field removed
-* Hyperlink tooltip is stored in the `Tooltip` field
-
-## 0.9.6 (2017-03-25)
-
-* `sheet_to_json` now passes `null` values when `raw` is set to `true`
-* `sheet_to_json` treats `null` stub cells as values in conjunction with `raw`
-
-## 0.9.5 (2017-03-22)
-
-* `cellDates` affects parsing in non-XLSX formats
-
-## 0.9.3 (2017-03-15)
-
-* XLML property names are more closely mapped to the XLSX equivalent
-* Stub cells are now cell type `z`
-
-## 0.9.2 (2017-03-13)
-
-* Removed stale TypeScript definition files.  Flowtype comments are used in the
-  `xlsx.flow.js` source and stripped to produce `xlsx.js`.
-* sed usage reworked to support GNU sed in-place form.  BSD sed seems to work,
-  but the build script has not been tested on other sed variants:
-
-```bash
-$ sed -i.ext  [...] # GNU
-$ sed -i .ext [...] # bsd
-```
-
-## 0.9.0 (2017-03-09)
-
-* Removed ods.js source.  The xlsx.js source absorbed the ODS logic and exposes
-  the ODS variable, so projects should remove references to ods.js
-