@silverbulletmd/silverbullet 2.4.1 → 2.5.3

package/client/space_lua/stdlib/prng.ts

@@ -0,0 +1,145 @@
+// PRNG based on xoshiro256** for Space Lua
+
+export class LuaPRNG {
+  private state: BigUint64Array;
+
+  constructor() {
+    this.state = new BigUint64Array(4);
+    this.autoSeed();
+  }
+
+  private rotl(x: bigint, k: number): bigint {
+    k = k & 63;
+    return ((x << BigInt(k)) | (x >> BigInt(64 - k))) & 0xFFFFFFFFFFFFFFFFn;
+  }
+
+  private nextrand(): bigint {
+    const s = this.state;
+    const s0 = s[0];
+    const s1 = s[1];
+    const s2 = s[2];
+    const s3 = s[3];
+
+    const res = this.rotl((s1 * 5n) & 0xFFFFFFFFFFFFFFFFn, 7) * 9n &
+      0xFFFFFFFFFFFFFFFFn;
+
+    const t = (s1 << 17n) & 0xFFFFFFFFFFFFFFFFn;
+    s[2] = s2 ^ s0;
+    s[3] = s3 ^ s1;
+    s[1] = s1 ^ s[2];
+    s[0] = s0 ^ s[3];
+    s[2] = s[2] ^ t;
+    s[3] = this.rotl(s[3], 45);
+
+    return res;
+  }
+
+  public setSeed(seed1: bigint, seed2: bigint = 0n): [bigint, bigint] {
+    const MASK = 0xFFFFFFFFFFFFFFFFn;
+    const s = this.state;
+
+    const sm64 = (x: bigint): bigint => {
+      x = (x ^ (x >> 30n)) * 0xBF58476D1CE4E5B9n & MASK;
+      x = (x ^ (x >> 27n)) * 0x94D049BB133111EBn & MASK;
+      return (x ^ (x >> 31n)) & MASK;
+    };
+
+    s[0] = sm64(seed1 & MASK);
+    s[1] = sm64((seed1 & MASK) | 0xFFn);
+    s[2] = sm64(seed2 & MASK);
+    s[3] = sm64(0n);
+
+    for (let i = 0; i < 16; i++) {
+      this.nextrand();
+    }
+
+    return [seed1, seed2];
+  }
+
+  private autoSeed(): [bigint, bigint] {
+    const t = BigInt(Date.now());
+    const entropy = BigInt(Math.floor(performance.now() * 1000));
+    return this.setSeed(t, entropy);
+  }
+
+  private project(ran: bigint, n: bigint): bigint {
+    if (n === 0n) return 0n;
+
+    let lim = n;
+    lim |= lim >> 1n;
+    lim |= lim >> 2n;
+    lim |= lim >> 4n;
+    lim |= lim >> 8n;
+    lim |= lim >> 16n;
+    lim |= lim >> 32n;
+
+    while (true) {
+      ran &= lim;
+      if (ran <= n) return ran;
+      ran = this.nextrand();
+    }
+  }
+
+  // `random()` yields float in [0, 1)
+  // `random(0)` yields raw 64-bit signed integer (all bits random)
+  // `random(n)` yields integer in [1, n]
+  // `random(m, n)` yields integer in [m, n]
+  public random(arg1?: number, arg2?: number): number | bigint {
+    const rv = this.nextrand();
+
+    if (arg1 === undefined) {
+      // Top 53 bits for full double precision
+      return Number(rv >> 11n) * (1.0 / 9007199254740992.0);
+    }
+
+    if (!Number.isFinite(arg1) || !Number.isInteger(arg1)) {
+      throw new Error(
+        "bad argument #1 to 'random' (number has no integer representation)",
+      );
+    }
+
+    if (arg2 === undefined) {
+      if (arg1 === 0) {
+        // Raw 64-bit as signed bigint
+        const signed = rv > 0x7FFFFFFFFFFFFFFFn
+          ? rv - 0x10000000000000000n
+          : rv;
+        return signed;
+      }
+      if (arg1 < 1) {
+        throw new Error("bad argument #1 to 'random' (interval is empty)");
+      }
+      return Number(this.project(rv, BigInt(arg1) - 1n) + 1n);
+    }
+
+    if (!Number.isFinite(arg2) || !Number.isInteger(arg2)) {
+      throw new Error(
+        "bad argument #2 to 'random' (number has no integer representation)",
+      );
+    }
+    if (arg2 < arg1) {
+      throw new Error("bad argument #2 to 'random' (interval is empty)");
+    }
+    return Number(this.project(rv, BigInt(arg2) - BigInt(arg1)) + BigInt(arg1));
+  }
+
+  // Returns [seed1, seed2]
+  public randomseed(arg1?: number, arg2?: number): [bigint, bigint] {
+    if (arg1 === undefined) {
+      return this.autoSeed();
+    }
+    if (!Number.isFinite(arg1) || !Number.isInteger(arg1)) {
+      throw new Error(
+        "bad argument #1 to 'randomseed' (number has no integer representation)",
+      );
+    }
+    if (arg2 !== undefined && (!Number.isFinite(arg2) || !Number.isInteger(arg2))) {
+      throw new Error(
+        "bad argument #2 to 'randomseed' (number has no integer representation)",
+      );
+    }
+    const s1 = BigInt(Math.trunc(arg1));
+    const s2 = arg2 !== undefined ? BigInt(Math.trunc(arg2)) : 0n;
+    return this.setSeed(s1, s2);
+  }
+}

package/client/space_lua/stdlib/space_lua.ts

@@ -137,17 +137,12 @@ export const spaceluaApi = new LuaTable({
     },
   ),
   /**
-   * Returns your SilverBullet instance's base URL, or `undefined` when run on the server
+   * Returns your SilverBullet instance's base URL
    */
   baseUrl: new LuaBuiltinFunction(
     () => {
-      // Deal with Deno
-      if (typeof location === "undefined") {
-        return null;
-      } else {
-        //NOTE: Removing trailing slash to stay compatible with original code: `location.protocol + "//" + location.host;`
-        return document.baseURI.replace(/\/*$/, "");
-      }
+      //NOTE: Removing trailing slash to stay compatible with original code: `location.protocol + "//" + location.host;`
+      return document.baseURI.replace(/\/*$/, "");
     },
   ),
 });

package/client/space_lua/stdlib/string.ts

@@ -6,79 +6,35 @@ import {
   LuaTable,
   luaToString,
 } from "../runtime.ts";
-import { untagNumber } from "../numeric.ts";
+import { isTaggedFloat, untagNumber } from "../numeric.ts";
 import { luaFormat } from "./format.ts";
-
-// Bits and pieces borrowed from https://github.com/paulcuth/starlight/blob/master/src/runtime/lib/string.js
-
-const ROSETTA_STONE = {
-  "([^a-zA-Z0-9%(])-": "$1*?",
-  "([^%])-([^a-zA-Z0-9?])": "$1*?$2",
-  "([^%])-$": "$1*?",
-  "%a": "[a-zA-Z]",
-  "%A": "[^a-zA-Z]",
-  "%c": "[\x00-\x1f]",
-  "%C": "[^\x00-\x1f]",
-  "%d": "\\d",
-  "%D": "[^\d]",
-  "%l": "[a-z]",
-  "%L": "[^a-z]",
-  "%p": "[\.\,\"'\?\!\;\:\#\$\%\&\(\)\*\+\-\/\<\>\=\@\\[\\]\\\\^\_\{\}\|\~]",
-  "%P": "[^\.\,\"'\?\!\;\:\#\$\%\&\(\)\*\+\-\/\<\>\=\@\\[\\]\\\\^\_\{\}\|\~]",
-  "%s": "[ \\t\\n\\f\\v\\r]",
-  "%S": "[^ \t\n\f\v\r]",
-  "%u": "[A-Z]",
-  "%U": "[^A-Z]",
-  "%w": "[a-zA-Z0-9]",
-  "%W": "[^a-zA-Z0-9]",
-  "%x": "[a-fA-F0-9]",
-  "%X": "[^a-fA-F0-9]",
-  "%([^a-zA-Z])": "\\$1",
-};
-
-function translatePattern(pattern: string): string {
-  pattern = "" + pattern;
-
-  // Replace single backslash with double backslashes
-  pattern = pattern.replace(new RegExp("\\\\", "g"), "\\\\");
-  pattern = pattern.replace(new RegExp("\\|", "g"), "\\|");
-
-  for (const [key, value] of Object.entries(ROSETTA_STONE)) {
-    pattern = pattern.replace(new RegExp(key, "g"), value);
-  }
-
-  let l = pattern.length;
-  let n = 0;
-
-  for (let i = 0; i < l; i++) {
-    const character = pattern.slice(i, 1);
-    if (i && pattern.slice(i - 1, 1) == "\\") {
-      continue;
-    }
-
-    let addSlash = false;
-
-    if (character == "[") {
-      if (n) addSlash = true;
-      n++;
-    } else if (character == "]" && pattern.slice(i - 1, 1) !== "\\") {
-      n--;
-      if (n) addSlash = true;
-    }
-
-    if (addSlash) {
-      pattern = pattern.slice(0, i) + pattern.slice(i++ + 1);
-      l++;
-    }
+import {
+  type CaptureResult,
+  type GsubCallbacks,
+  patternFind,
+  patternGmatch,
+  patternGsub,
+  patternMatch,
+} from "./pattern.ts";
+import { strPackFn, strPackSizeFn, strUnpackFn } from "./string_pack.ts";
+
+function capturesToLua(caps: CaptureResult[]): any {
+  if (caps.length === 0) return null;
+  if (caps.length === 1) {
+    const c = caps[0];
+    return "s" in c ? c.s : c.position;
   }
-
-  return pattern;
+  return new LuaMultiRes(
+    caps.map((c) => ("s" in c ? c.s : c.position)),
+  );
 }
 
 export const stringApi = new LuaTable({
   byte: new LuaBuiltinFunction((_sf, s: string, i?: number, j?: number) => {
     i = i ?? 1;
     j = j ?? i;
+    if (j > s.length) j = s.length;
+    if (i < 1) i = 1;
     const result = [];
     for (let k = i; k <= j; k++) {
       result.push(s.charCodeAt(k - 1));
@@ -90,119 +46,70 @@ export const stringApi = new LuaTable({
   }),
   find: new LuaBuiltinFunction(
     (_sf, s: string, pattern: string, init = 1, plain = false) => {
-      // Regex
-      if (!plain) {
-        pattern = translatePattern(pattern);
-        const reg = new RegExp(pattern);
-        const index = s.slice(init - 1).search(reg);
-
-        if (index < 0) return null;
-
-        const match = s.slice(init - 1).match(reg);
-        const result = [index + init, index + init + match![0].length - 1];
-
-        match!.shift();
-        return new LuaMultiRes(result.concat(match));
+      const r = patternFind(s, pattern, init, plain);
+      if (!r) return null;
+      const result: any[] = [r.start, r.end];
+      for (const c of r.captures) {
+        result.push("s" in c ? c.s : c.position);
       }
-
-      // Plain
-      const index = s.indexOf(pattern, init - 1);
-      return (index === -1)
-        ? null
-        : new LuaMultiRes([index + 1, index + pattern.length]);
+      return new LuaMultiRes(result);
     },
   ),
   format: new LuaBuiltinFunction((_sf, format: string, ...args: any[]) => {
-    // Unwrap tagged floats so luaFormat sees plain numbers
     for (let i = 0; i < args.length; i++) {
       args[i] = untagNumber(args[i]);
     }
     return luaFormat(format, ...args);
   }),
-  gmatch: new LuaBuiltinFunction((_sf, s: string, pattern: string) => {
-    pattern = translatePattern(pattern);
-    const reg = new RegExp(pattern, "g"),
-      matches = s.match(reg);
-    return () => {
-      if (!matches) {
-        return;
-      }
-      const match = matches.shift();
-      if (!match) {
-        return;
-      }
-      const groups = new RegExp(pattern).exec(match) || [];
-
-      groups.shift();
-      return groups.length ? new LuaMultiRes(groups) : match;
-    };
-  }),
+  gmatch: new LuaBuiltinFunction(
+    (_sf, s: string, pattern: string, init = 1) => {
+      const iter = patternGmatch(s, pattern, init);
+      return () => {
+        const caps = iter();
+        if (!caps) return;
+        return capturesToLua(caps);
+      };
+    },
+  ),
   gsub: new LuaBuiltinFunction(
     async (
       sf,
       s: string,
       pattern: string,
-      repl: any, // string or LuaFunction
-      n = Infinity,
+      repl: any,
+      n?: number,
     ) => {
-      pattern = translatePattern(pattern);
-      const replIsFunction = repl.call;
-
-      let count = 0,
-        result = "",
-        str,
-        prefix,
-        match: any,
-        lastMatch;
-
-      while (
-        count < n &&
-        s &&
-        (match = s.match(pattern))
-      ) {
-        if (replIsFunction) {
-          // If no captures, pass in the whole match
-          if (match[1] === undefined) {
-            str = await repl.call(sf, match[0]);
-          } else {
-            // Else pass in the captures
-            str = await repl.call(sf, ...match.slice(1));
-          }
-          if (str instanceof LuaMultiRes) {
-            str = str.values[0];
-          }
-          if (str === undefined || str === null) {
-            str = match[0];
+      const callbacks: GsubCallbacks = {};
+      if (typeof repl === "string") {
+        callbacks.replString = repl;
+      } else if (repl instanceof LuaTable) {
+        callbacks.replTable = (key: string) => {
+          const v = repl.get(key);
+          if (v === null || v === undefined || v === false) return null;
+          return typeof v === "number"
+            ? String(v)
+            : String(isTaggedFloat(v) ? v.value : v);
+        };
+      } else if (repl.call) {
+        callbacks.replFunction = async (...caps: CaptureResult[]) => {
+          const args = caps.map((c) => ("s" in c ? c.s : c.position));
+          let result = await repl.call(sf, ...args);
+          if (result instanceof LuaMultiRes) {
+            result = result.values[0];
           }
-        } else if (repl instanceof LuaTable) {
-          str = repl.get(match[0]);
-        } else if (typeof repl === "string") {
-          str = repl.replaceAll(/%([0-9]+)/g, (_, i) => match[i]);
-        } else {
-          throw new LuaRuntimeError(
-            "string.gsub replacement argument should be a function, table or string",
-            sf,
-          );
-        }
-
-        if (match[0].length === 0) {
-          if (lastMatch === void 0) {
-            prefix = "";
-          } else {
-            prefix = s.slice(0, 1);
+          if (result === null || result === undefined || result === false) {
+            return null;
           }
-        } else {
-          prefix = s.slice(0, match.index);
-        }
-
-        lastMatch = match[0];
-        result += `${prefix}${str}`;
-        s = s.slice(`${prefix}${lastMatch}`.length);
-
-        count++;
+          return luaToString(result);
+        };
+      } else {
+        throw new LuaRuntimeError(
+          "string.gsub replacement argument should be a function, table or string",
+          sf,
+        );
       }
-
-      return new LuaMultiRes([`${result}${s}`, count]);
+      const [result, count] = await patternGsub(s, pattern, callbacks, n);
+      return new LuaMultiRes([result, count]);
     },
   ),
   len: new LuaBuiltinFunction((_sf, s: string) => {
@@ -216,43 +123,58 @@ export const stringApi = new LuaTable({
   }),
   match: new LuaBuiltinFunction(
     (_sf, s: string, pattern: string, init = 1) => {
-      s = s.slice(init - 1);
-      const matches = s.match(new RegExp(translatePattern(pattern)));
-
-      if (!matches) {
-        return null;
-      }
-      if (matches[1] === undefined) {
-        // No captures
-        return matches[0];
-      }
-
-      matches.shift();
-      return new LuaMultiRes(matches);
+      const caps = patternMatch(s, pattern, init);
+      if (!caps) return null;
+      return capturesToLua(caps);
     },
   ),
   rep: new LuaBuiltinFunction((_sf, s: string, n: number, sep?: string) => {
+    if (n <= 0) return "";
     sep = sep ?? "";
-    return s.repeat(n) + sep;
+    const parts: string[] = [];
+    for (let i = 0; i < n; i++) {
+      parts.push(s);
+    }
+    return parts.join(sep);
   }),
   reverse: new LuaBuiltinFunction((_sf, s: string) => {
     return s.split("").reverse().join("");
   }),
   sub: new LuaBuiltinFunction((_sf, s: string, i: number, j?: number) => {
-    j = j ?? s.length;
-    if (i < 0) {
-      i = s.length + i + 1;
+    const len = s.length;
+    let start: number;
+    if (i > 0) {
+      start = i;
+    } else if (i < -len) {
+      start = 1;
+    } else {
+      start = i === 0 ? 1 : len + i + 1;
     }
-    if (j < 0) {
-      j = s.length + j + 1;
+    let end: number;
+    if (j === undefined || j === null || j > len) {
+      end = len;
+    } else if (j >= 0) {
+      end = j;
+    } else if (j < -len) {
+      end = 0;
+    } else {
+      end = len + j + 1;
     }
-    return s.slice(i - 1, j);
+    if (start <= end) {
+      return s.substring(start - 1, end);
+    }
+    return "";
   }),
+
   split: new LuaBuiltinFunction((_sf, s: string, sep: string) => {
     return s.split(sep);
   }),
 
-  // Non-standard
+  pack: strPackFn,
+  unpack: strUnpackFn,
+  packsize: strPackSizeFn,
+
+  // Non-standard extensions
   startsWith: new LuaBuiltinFunction((_sf, s: string, prefix: string) => {
     return s.startsWith(prefix);
   }),