datafolder 1.0.18 → 1.0.20

package/src/QyUnionNode.js

@@ -16,9 +16,9 @@ class i {
     encounterOne(i) {
         var {
             encounteredMap: e,
-            isFull: r
+            isFull: t
         } = this;
-        if (!(r || i in e)) return e[i] = 1, this.countOne();
+        if (!(t || i in e)) return e[i] = 1, this.countOne();
     }
     countOne() {
         if (this.count++ >= this.cursor) return ++this.added, !0;
@@ -29,67 +29,67 @@ class e {
     fileCount = 0;
     nodeList = [];
     constructor() {}
-    encounterOne(i, e, r) {
-        if (!r || r.encounterOne(e)) return i[e] = 1, !0;
+    encounterOne(i, e, t) {
+        if (!t || t.encounterOne(e)) return i[e] = 1, !0;
     }
 }
 
 class o extends e {
-    dirMap = {};
+    fileMap = {};
     checkedDirMap = {};
     constructor(i = void 0) {
-        super(), i && this.addDir(i);
+        super(), i && this.addItem(i);
     }
-    containsFile(e) {
+    containsFile(i) {
         var {
-            fileCount: i,
-            dirMap: r,
-            nodeList: t
+            fileCount: e,
+            fileMap: t,
+            nodeList: n
         } = this;
-        if (0 < i) {
-            for (var n in r) if (null != r[n].getFile(e)) return !0;
-            for (let i = 0; i < t.length; ++i) if (t[i].containsFile(e)) return !0;
+        if (0 < e) {
+            for (var r in t) {
+                r = t[r].fileContent;
+                if (r && Object.hasOwn(r, i)) return !0;
+            }
+            for (var s of n) if (s.containsFile(i)) return !0;
         }
         return !1;
     }
     *getFiles(i = void 0, e = {}) {
-        var r, t, {
-            dirMap: n,
+        var t, n, {
+            fileMap: r,
             nodeList: s
         } = this;
-        for (r in n) {
-            var o = n[r];
-            if (0 != o.fileCount) for (var u of o.fileNameList) if (!(u in e) && this.encounterOne(e, u, i) && (yield u, 
-            i?.isFull)) return;
-        }
-        for (t of s) if (yield* t.getFiles(i, e), i?.isFull) return;
+        for (t in r) for (var o in r[t].fileContent) if (!(o in e) && this.encounterOne(e, o, i) && (yield o, 
+        i?.isFull)) return;
+        for (n of s) if (yield* n.getFiles(i, e), i?.isFull) return;
     }
     addNode(i) {
         if (i) {
             var {
-                dirMap: e,
-                checkedDirMap: r,
-                nodeList: t
+                fileMap: e,
+                checkedDirMap: t,
+                nodeList: n
             } = this;
             if (i instanceof o) {
-                for (var n in i.dirMap) e[n] = i.dirMap[n];
-                for (var s in t.push(...i.nodeList), i.checkedDirMap) r[s] = 1;
-            } else t.push(i);
+                for (var r in i.fileMap) e[r] = i.fileMap[r];
+                for (var s in n.push(...i.nodeList), i.checkedDirMap) t[s] = 1;
+            } else n.push(i);
             this.fileCount += i.fileCount;
         }
     }
-    addDir(i) {
+    addItem(i) {
         var {
-            dirMap: e,
-            checkedDirMap: r
+            fileMap: e,
+            checkedDirMap: t
         } = this, {
-            fileCount: t,
-            subdirCount: n,
-            fullPathHash: s
+            isFile: n,
+            fullPathHash: r
         } = i;
-        if (!(s in e || s in r)) {
-            if (0 < n) for (var o of i.subdirList) this.addDir(o);
-            0 < t ? (e[s] = i, this.fileCount += t) : r[s] = 1;
+        if (n) e[r] = i, ++this.fileCount; else if (!(r in t)) {
+            for (var s of i.subdirList) this.addItem(s);
+            for (var o of i.fileList) this.addItem(o);
+            t[r] = 1;
         }
     }
 }

package/src/QyUtils.d.ts

@@ -1,6 +1,6 @@
 import util from "node:util";
 export declare const isArray: (arg: any) => arg is any[];
-export declare const isDate: typeof util.types.isDate, isFloat32Array: typeof util.types.isFloat32Array;
+export declare const isDate: typeof util.types.isDate, isFloat32Array: typeof util.types.isFloat32Array, isUint8Array: typeof util.types.isUint8Array;
 export declare const __dirname: string;
 export declare const SpecialOperators: {
     [k: string]: string;
@@ -11,8 +11,9 @@ export declare const SpecialFilePaths: {
     RpcDirPath: string[];
     IndexDirPath: string[];
     ExpireDirPath: string[];
-    EmbeddingDirPath: string[];
-    H2FDirPath: string[];
+    HNSWDirPath: string[];
+    InfoDirPath: string[];
+    RecycleDirPath: string[];
     MetaFilePath: string[];
     IndexPropPathsFileName: string;
 };
@@ -58,4 +59,5 @@ export declare function loadFileList(fileList: any, preloadCount?: number): Asyn
 }, void, unknown>;
 export declare function getNowTime(now?: Date): number;
 export declare function getNowRounded(now?: Date): number;
+export declare function readBufferFromFD(fd: any, filePath: any, start: any, length: any): Buffer<ArrayBuffer> | undefined;
 export * as default from "./QyUtils.ts";

package/src/QyUtils.js

@@ -6,7 +6,9 @@ import e from "node:process";
 
 import l from "node:fs/promises";
 
-import i from "node:fs";
+import i, {
+    readSync as u
+} from "node:fs";
 
 import o from "node:timers/promises";
 
@@ -17,122 +19,124 @@ import {
 import a from "node:util";
 
 import {
-    logger as u
+    logger as f
 } from "../src/QyLogger.js";
 
-let f = Array.isArray, {
+let c = Array.isArray, {
     isDate: s,
-    isFloat32Array: c
+    isFloat32Array: d,
+    isUint8Array: m
 } = a.types;
 
-var m = t.dirname(r(import.meta.url)), d = Object.fromEntries([ "$del", "$link", "$rpl", "$spec", "$raw", "$all", "$clone", "$ext", "$or", "$and", "$gt", "$lt", "$gte", "$lte", "$f32" ].map(r => [ r, r ])), p = "%", p = {
-    HiddenFolderName: p,
-    TriggerDirPath: [ p, "trigger" ],
-    RpcDirPath: [ p, "rpc" ],
-    IndexDirPath: [ p, "index" ],
-    ExpireDirPath: [ p, "expire" ],
-    EmbeddingDirPath: [ p, "embedding" ],
-    H2FDirPath: [ p, "h2F" ],
-    MetaFilePath: [ p, "meta" ],
+var p = t.dirname(r(import.meta.url)), h = Object.fromEntries([ "$del", "$link", "$rpl", "$spec", "$raw", "$all", "$clone", "$ext", "$pop", "$or", "$and", "$gt", "$lt", "$gte", "$lte", "$u8" ].map(r => [ r, r ])), y = "%", y = {
+    HiddenFolderName: y,
+    TriggerDirPath: [ y, "trigger" ],
+    RpcDirPath: [ y, "rpc" ],
+    IndexDirPath: [ y, "index" ],
+    ExpireDirPath: [ y, "expire" ],
+    HNSWDirPath: [ y, "hnsw" ],
+    InfoDirPath: [ y, "info" ],
+    RecycleDirPath: [ y, "recycle" ],
+    MetaFilePath: [ y, "meta" ],
     IndexPropPathsFileName: "propPaths"
 };
 
-function h(r) {
+function g(r) {
     return r.startsWith("{") && r.endsWith("}");
 }
 
-function g(r) {
-    return h(r) && r.substring(1, r.length - 1);
+function v(r) {
+    return g(r) && r.substring(1, r.length - 1);
 }
 
-function y(r) {
+function b(r) {
     return 1e12 < r ? Math.round(100 * r / 1e12) / 100 + "TB" : 1e9 < r ? Math.round(100 * r / 1e9) / 100 + "GB" : 1e6 < r ? Math.round(100 * r / 1e6) / 100 + "MB" : 1e3 < r ? Math.round(100 * r / 1e3) / 100 + "KB" : r.toString();
 }
 
-function b(r, t = 10) {
+function $(r, t = 10) {
     return n.createHash("sha256").update(r, "utf8").digest("base64url").slice(0, t);
 }
 
-var v = 11;
+var w = 11;
 
-function $(r) {
+function P(r) {
     return "d" + r;
 }
 
-function w(r) {
+function S(r) {
     return "f" + r;
 }
 
-function P(r) {
+function x(r) {
     return "c" + r;
 }
 
-function x(r = 8) {
+function D(r = 8) {
     return n.randomBytes(r).toString("hex");
 }
 
-function S(r) {
+function j(r) {
     if (null != r) for (var t in r) if (null != r[t]) return !1;
     return !0;
 }
 
-function j(r) {
+function B(r) {
     return null != r && "object" == typeof r && !s(r);
 }
 
-function D(r) {
+function M(r) {
     return "string" == typeof r;
 }
 
-function F(r) {
+function T(r) {
     return "number" == typeof r;
 }
 
-function M(r) {
+function N(r) {
     return "boolean" == typeof r;
 }
 
-function B(r) {
+function W(r) {
     return "function" == typeof r;
 }
 
-function N(r) {
+function E(r) {
     var t = typeof r;
-    return "string" == t || "number" == t || "boolean" == t || c(r) || s(r);
+    return "string" == t || "number" == t || "boolean" == t || m(r) || s(r);
 }
 
-function U(r) {
+function R(r) {
     let t = r.length;
     for (;null == r[t - 1] && 0 < t; ) --t;
     return r.length = t, r;
 }
 
-function W(n) {
+function H(n) {
     return n.promise || (n.promise = new Promise((r, t) => Object.assign(n, {
         resolve: r,
         reject: t
     }))), n;
 }
 
-function H(r) {
+function L(r) {
     return Buffer.isBuffer(r) ? r : Buffer.from(r);
 }
 
-function L(r) {
+function G(r) {
     return 1 < r ? "s" : "";
 }
 
-function T(r) {
+function F(r) {
     return l.mkdir(r, {
         recursive: !0
     });
 }
 
-function O(r) {
-    return T(t.dirname(r));
+function I(r) {
+    return F(t.dirname(r));
 }
 
-async function k(r) {
+async function O(r) {
     try {
         return (await l.stat(r)).size;
     } catch (r) {
@@ -140,111 +144,111 @@ async function k(r) {
     }
 }
 
-async function R(r) {
-    return !1 !== await k(r);
+async function J(r) {
+    return !1 !== await O(r);
 }
 
-function G(r, t = void 0) {
+function Q(r, t = void 0) {
     r *= 1e3;
     return t ? o.setTimeout(r, !0, {
         signal: t
     }) : o.setTimeout(r);
 }
 
-let I;
+let U;
 
-async function J(t) {
+async function z(t) {
     try {
-        await O(t);
+        await I(t);
         var r = new Date().toISOString() + ": " + e.argv.join(" ");
         function n() {
-            for (var r of Object.keys(I)) A(r);
+            for (var r of Object.keys(U)) k(r);
         }
         await l.writeFile(t, r, {
             flag: "wx",
             flush: !0
-        }), u.info("Locked " + t), I ? I[t] = 1 : (I = {
+        }), f.info("Locked " + t), U ? U[t] = 1 : (U = {
             [t]: 1
         }, e.on("exit", n), e.on("SIGINT", n));
     } catch (r) {
-        throw "EEXIST" == r.code && u.error(`Already started by ${(await l.readFile(t)).toString()}:`, r), 
+        throw "EEXIST" == r.code && f.error(`Already started by ${(await l.readFile(t)).toString()}:`, r), 
         r;
     }
 }
 
-function A(r) {
+function k(r) {
     try {
-        i.unlinkSync(r), u.info("Unlocked " + r);
+        i.unlinkSync(r), f.info("Unlocked " + r);
     } catch (r) {}
 }
 
-function Q(r) {
+function K(r) {
     return r.startsWith("[") && r.endsWith("]") ? JSON.parse(r) : r;
 }
 
-function z(r) {
-    return f(r) ? 1 == r.length ? r[0] : JSON.stringify(r) : r;
+function X(r) {
+    return c(r) ? 1 == r.length ? r[0] : JSON.stringify(r) : r;
 }
 
-function K(r) {
+function q(r) {
     r = r.split("/");
     return r[0] || (r[0] = "/"), r;
 }
 
-function E(r) {
+function A(r) {
     return r.split(".");
 }
 
-function X(r) {
-    return D(r) ? [ E(r) ] : f(r) ? r.map(r => D(r) ? E(r) : r) : void 0;
+function C(r) {
+    return M(r) ? [ A(r) ] : c(r) ? r.map(r => M(r) ? A(r) : r) : void 0;
 }
 
-function q(r) {
+function V(r) {
     return r.join(".");
 }
 
-function C(r, t = 0) {
+function Y(r, t = 0) {
     return Math.floor(Math.random() * (r - t)) + t;
 }
 
-function V(r) {
+function Z(r) {
     var t, n = {};
     for (t of r) n[t] = 1;
     return n;
 }
 
-async function Y(t, n, e, i) {
+async function _(t, n, e, i) {
     var o = Buffer.allocUnsafe(i);
     for (let r = 0; r < i; ) {
         var a = (await n.read(o, r, i - r, e + r)).bytesRead;
-        if (0 == a) return void u.error(`read ${t} at ${e + r} returning 0 byte`);
+        if (0 == a) return void f.error(`read ${t} at ${e + r} returning 0 byte`);
         r += a;
     }
     return o;
 }
 
-function Z() {
+function rr() {
     var r = e.availableMemory();
     return Math.round(r / (e.memoryUsage.rss() + r) * 100);
 }
 
-async function* _(e, t = 3) {
+async function* tr(e, t = 3) {
     var n = e.length, i = (n < t && (t = n), new Array(n));
     for (let r = 0; r < t; ++r) {
         var o = i[r] = {};
-        c(r, o);
+        s(r, o);
     }
     for (let r = 0; r < n; ++r) {
         var a = i[r % t], {
             filePath: u,
             bin: f
-        } = (a.bin || await a.promise, a), s = r + t;
-        s < n && c(s, a), yield {
+        } = (a.bin || await a.promise, a), c = r + t;
+        c < n && s(c, a), yield {
             filePath: u,
             bin: f
         };
     }
-    async function c(r, t) {
+    async function s(r, t) {
         var r = e[r], n = l.readFile(r);
         Object.assign(t, {
             filePath: r,
@@ -254,61 +258,73 @@ async function* _(e, t = 3) {
     }
 }
 
-function rr(r = new Date()) {
+function nr(r = new Date()) {
     return r.getTime();
 }
 
-function tr(r = new Date()) {
+function er(r = new Date()) {
     r = r.getTime();
     return r - r % 1e3;
 }
 
+function ir(t, n, e, i) {
+    var o = Buffer.allocUnsafe(i);
+    for (let r = 0; r < i; ) {
+        var a = u(t, o, r, i - r, e + r);
+        if (0 == a) return void f.error(`readSync ${n} at ${e + r} returning 0 byte`);
+        r += a;
+    }
+    return o;
+}
+
 export * as default from "./QyUtils.js";
 
 export {
-    f as isArray,
+    c as isArray,
     s as isDate,
-    c as isFloat32Array,
-    m as __dirname,
-    d as SpecialOperators,
-    p as SpecialFilePaths,
-    h as isMatchName,
-    g as getMatchParam,
-    y as getSizeStr,
-    b as calHash,
-    v as Hash_Key_Length,
-    $ as getSubdirMapKey,
-    w as getFileMapKey,
-    P as getContentKey,
-    x as getRandomStr,
-    S as isEmptyObj,
-    j as isNotNullObj,
-    D as isString,
-    F as isNumber,
-    M as isBoolean,
-    B as isFunction,
-    N as isSimpleType,
-    U as trimArrayTail,
-    W as setPromise,
-    H as toBuffer,
-    L as getSuffix,
-    T as ensureDir,
-    O as ensureParentDir,
-    k as getSize,
-    R as folderOrFileExists,
-    G as sleep,
-    J as lockExclusiveFilePath,
-    A as unlockExclusiveFilePath,
-    Q as fromSingleName,
-    z as toSingleName,
-    K as pathSplit,
-    X as ensurePropNamePathList,
-    q as propNameJoin,
-    C as randomInt,
-    V as listToMap,
-    Y as readBufferAsync,
-    Z as memoryPercent,
-    _ as loadFileList,
-    rr as getNowTime,
-    tr as getNowRounded
+    d as isFloat32Array,
+    m as isUint8Array,
+    p as __dirname,
+    h as SpecialOperators,
+    y as SpecialFilePaths,
+    g as isMatchName,
+    v as getMatchParam,
+    b as getSizeStr,
+    $ as calHash,
+    w as Hash_Key_Length,
+    P as getSubdirMapKey,
+    S as getFileMapKey,
+    x as getContentKey,
+    D as getRandomStr,
+    j as isEmptyObj,
+    B as isNotNullObj,
+    M as isString,
+    T as isNumber,
+    N as isBoolean,
+    W as isFunction,
+    E as isSimpleType,
+    R as trimArrayTail,
+    H as setPromise,
+    L as toBuffer,
+    G as getSuffix,
+    F as ensureDir,
+    I as ensureParentDir,
+    O as getSize,
+    J as folderOrFileExists,
+    Q as sleep,
+    z as lockExclusiveFilePath,
+    k as unlockExclusiveFilePath,
+    K as fromSingleName,
+    X as toSingleName,
+    q as pathSplit,
+    C as ensurePropNamePathList,
+    V as propNameJoin,
+    Y as randomInt,
+    Z as listToMap,
+    _ as readBufferAsync,
+    rr as memoryPercent,
+    tr as loadFileList,
+    nr as getNowTime,
+    er as getNowRounded,
+    ir as readBufferFromFD
 };

package/static/codemirror.bundle/editor.bundle.js

@@ -6916,6 +6916,7 @@
               if (composition && next.fromA <= composition.range.fromA && next.toA >= composition.range.toA) {
                   this.forward(next.fromA, composition.range.fromA, composition.range.fromA < composition.range.toA ? 1 : -1);
                   this.emit(posB, composition.range.fromB);
+                  this.builder.flushBuffer();
                   this.cache.clear(); // Must not reuse DOM across composition
                   this.builder.addComposition(composition, compositionContext);
                   this.text.skip(composition.range.toB - composition.range.fromB);
@@ -8129,12 +8130,11 @@
       }
       // Scan through the rectangles for the content of a tile with inline
       // content, looking for one that overlaps the queried position
-      // vertically andis
-      // closest horizontally. The caller is responsible for dividing its
-      // content into N pieces, and pass an array with N+1 positions
-      // (including the position after the last piece). For a text tile,
-      // these will be character clusters, for a composite tile, these
-      // will be child tiles.
+      // vertically and is closest horizontally. The caller is responsible
+      // for dividing its content into N pieces, and pass an array with
+      // N+1 positions (including the position after the last piece). For
+      // a text tile, these will be character clusters, for a composite
+      // tile, these will be child tiles.
       scan(positions, getRects, recursed = false) {
           let lo = 0, hi = positions.length - 1, seen = new Set();
           let bidi = this.bidiIn(positions[0], positions[hi]);
@@ -8206,6 +8206,8 @@
           // If no element with y overlap is found, find the nearest element
           // on the y axis, move this.y into it, and retry the scan.
           if (!closestRect) {
+              if (!below && !above)
+                  return { i: positions[0], after: false };
               let side = above && (!below || (this.y - above.bottom < below.top - this.y)) ? above : below;
               this.y = (side.top + side.bottom) / 2;
               return this.scan(positions, getRects, true);
@@ -11098,6 +11100,7 @@
           padding: "0 2px 0 6px"
       },
       ".cm-layer": {
+          userSelect: "none", // #1708
           position: "absolute",
           left: 0,
           top: 0,
@@ -24116,7 +24119,7 @@
           let result = this.result.map ? this.result.map(this.result, mapping) : this.result;
           if (!result)
               return new ActiveSource(this.source, 0 /* State.Inactive */);
-          return new ActiveResult(this.source, this.explicit, mapping.mapPos(this.limit), this.result, mapping.mapPos(this.from), mapping.mapPos(this.to, 1));
+          return new ActiveResult(this.source, this.explicit, mapping.mapPos(this.limit), result, mapping.mapPos(this.from), mapping.mapPos(this.to, 1));
       }
       touches(tr) {
           return tr.changes.touchesRange(this.from, this.to);
@@ -24568,6 +24571,9 @@
           for (let line of template.split(/\r\n?|\n/)) {
               while (m = /[#$]\{(?:(\d+)(?::([^{}]*))?|((?:\\[{}]|[^{}])*))\}/.exec(line)) {
                   let seq = m[1] ? +m[1] : null, rawName = m[2] || m[3] || "", found = -1;
+                  // `${0}` is the cursor's final position, after every other tab stop.
+                  if (seq === 0)
+                      seq = 1e9;
                   let name = rawName.replace(/\\[{}]/g, m => m[1]);
                   for (let i = 0; i < fields.length; i++) {
                       if (seq != null ? fields[i].seq == seq : name ? fields[i].name == name : false)
@@ -24682,7 +24688,8 @@
 
   The order of fields defaults to textual order, but you can add
   numbers to placeholders (`${1}` or `${1:defaultText}`) to provide
-  a custom order.
+  a custom order. `${0}` is special—it is always the last stop, where
+  the cursor ends up after tabbing through the other fields.
 
   To include a literal `{` or `}` in your template, put a backslash
   in front of it. This will be removed and the brace will not be
@@ -25248,7 +25255,7 @@
       return {
           pos: start,
           end: end,
-          above: view.state.doc.lineAt(start).to < end,
+          above: true,
           create() {
               return { dom: diagnosticsTooltip(view, found) };
           }