codebay 0.16.1 → 0.17.0

package/.mochi/svelte-compile/{chunk-gnf5cnct.js → chunk-en9cfkx7.js}

@@ -1330,9 +1330,6 @@ class DevalueError extends Error {
     this.root = root;
   }
 }
-function is_primitive(thing) {
-  return thing === null || typeof thing !== "object" && typeof thing !== "function";
-}
 var object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\x00");
 function is_plain_object(thing) {
   const proto = Object.getPrototypeOf(thing);
@@ -1341,6 +1338,9 @@ function is_plain_object(thing) {
 function get_type(thing) {
   return Object.prototype.toString.call(thing).slice(8, -1);
 }
+function is_buffer(thing) {
+  return typeof Buffer !== "undefined" && Buffer.isBuffer(thing);
+}
 function get_escaped_char(char) {
   switch (char) {
     case '"':
@@ -1410,23 +1410,130 @@ function is_valid_array_index_string(s) {
   }
   return is_valid_array_index(+s);
 }
-function valid_array_indices(array) {
-  const keys = Object.keys(array);
+function array_index_cut(keys) {
   for (var i = keys.length - 1;i >= 0; i--) {
     if (is_valid_array_index_string(keys[i])) {
       break;
     }
   }
-  keys.length = i + 1;
+  return i + 1;
+}
+function valid_array_indices(array) {
+  const keys = Object.keys(array);
+  keys.length = array_index_cut(keys);
   return keys;
 }
 
+// node_modules/devalue/src/operations.js
+function merge_operations(defaults, overrides) {
+  if (!overrides)
+    return defaults;
+  const merged = {};
+  for (const key of Object.keys(defaults)) {
+    merged[key] = overrides[key] ?? defaults[key];
+  }
+  return merged;
+}
+var NOT_PLAIN = Object.freeze({ kind: "not-plain" });
+var SYMBOL_KEYS = Object.freeze({ kind: "symbol-keys" });
+var stringify_operations = {
+  identify: (value) => value,
+  typeOf: (value) => value === null ? "null" : typeof value,
+  toPrimitive: (value) => value,
+  tagOf: (value) => get_type(value),
+  isThenable: (value) => typeof value.then === "function",
+  toPromise: (thenable) => Promise.resolve(thenable),
+  unbox: (boxed) => boxed.valueOf(),
+  toISOString: (date) => isNaN(date.getDate()) ? "" : date.toISOString(),
+  toStringValue: (value) => value.toString(),
+  regExpInfo: (regexp) => ({ source: regexp.source, flags: regexp.flags }),
+  valuesOf: (set) => set,
+  entriesOf: (map) => map,
+  viewInfo: (view) => {
+    if (is_buffer(view))
+      view = new Uint8Array(view);
+    return {
+      buffer: view.buffer,
+      byteOffset: view.byteOffset,
+      byteLength: view.byteLength,
+      length: view.length,
+      bufferByteLength: view.buffer.byteLength
+    };
+  },
+  toArrayBuffer: (buffer2) => buffer2,
+  lengthOf: (array) => array.length,
+  hasOwn: (value, key) => Object.hasOwn(value, key),
+  indicesOf: (array) => valid_array_indices(array),
+  shapeOf: (value) => {
+    if (!is_plain_object(value))
+      return NOT_PLAIN;
+    if (enumerable_symbols(value).length > 0)
+      return SYMBOL_KEYS;
+    return {
+      kind: Object.getPrototypeOf(value) === null ? "null-proto" : "plain",
+      keys: Object.keys(value)
+    };
+  },
+  get: (value, key) => value[key]
+};
+var default_stringify_operations = Object.freeze(stringify_operations);
+var array_buffer_byte_length = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+var shared_array_buffer_byte_length = typeof SharedArrayBuffer === "undefined" ? undefined : Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
+var parse_operations = {
+  fromPrimitive: (primitive) => primitive,
+  fromISOString: (iso) => new Date(iso),
+  fromStringValue: (tag, text) => {
+    if (tag === "URL")
+      return new URL(text);
+    if (tag === "URLSearchParams")
+      return new URLSearchParams(text);
+    return Temporal[tag.slice(9)].from(text);
+  },
+  fromArrayBuffer: (buffer2) => buffer2,
+  fromRegExpInfo: (source, flags) => new RegExp(source, flags),
+  fromViewInfo: (tag, buffer2, byteOffset, length) => {
+    try {
+      array_buffer_byte_length.call(buffer2);
+    } catch (error) {
+      if (!shared_array_buffer_byte_length)
+        throw error;
+      shared_array_buffer_byte_length.call(buffer2);
+    }
+    const Constructor = globalThis[tag];
+    return byteOffset !== undefined ? new Constructor(buffer2, byteOffset, length) : new Constructor(buffer2);
+  },
+  box: (value) => Object(value),
+  createArray: (length) => new Array(length),
+  createSparseArray: (length) => {
+    const array = [];
+    array[MAX_ARRAY_INDEX] = undefined;
+    delete array[MAX_ARRAY_INDEX];
+    array.length = length;
+    return array;
+  },
+  createObject: () => ({}),
+  createNullPrototypeObject: () => Object.create(null),
+  createSet: () => new Set,
+  createMap: () => new Map,
+  set: (target, key, value) => {
+    target[key] = value;
+  },
+  addValue: (set, value) => {
+    set.add(value);
+  },
+  addEntry: (map, key, value) => {
+    map.set(key, value);
+  }
+};
+var default_parse_operations = Object.freeze(parse_operations);
+
 // node_modules/devalue/src/stringify.js
-function stringify(value, reducers) {
-  const stringified = run(false, value, reducers);
+function stringify(value, reducers, options) {
+  const stringified = run(false, value, reducers, options);
   return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
 }
-function run(async, value, reducers) {
+function run(async, value, reducers, options) {
+  const ops = merge_operations(default_stringify_operations, options?.operations);
   const stringified = [];
   const indexes = new Map;
   const custom = [];
@@ -1438,20 +1545,26 @@ function run(async, value, reducers) {
   const keys = [];
   let p = 0;
   function flatten(thing, index2) {
-    if (thing === undefined)
+    const type = ops.typeOf(thing);
+    if (type === "undefined")
       return UNDEFINED;
-    if (Number.isNaN(thing))
-      return NAN;
-    if (thing === Infinity)
-      return POSITIVE_INFINITY;
-    if (thing === -Infinity)
-      return NEGATIVE_INFINITY;
-    if (thing === 0 && 1 / thing < 0)
-      return NEGATIVE_ZERO;
-    if (indexes.has(thing))
-      return indexes.get(thing);
+    let number;
+    if (type === "number") {
+      number = ops.toPrimitive(thing);
+      if (Number.isNaN(number))
+        return NAN;
+      if (number === Infinity)
+        return POSITIVE_INFINITY;
+      if (number === -Infinity)
+        return NEGATIVE_INFINITY;
+      if (number === 0 && 1 / number < 0)
+        return NEGATIVE_ZERO;
+    }
+    const id = ops.identify(thing);
+    if (indexes.has(id))
+      return indexes.get(id);
     index2 ??= p++;
-    indexes.set(thing, index2);
+    indexes.set(id, index2);
     for (const { key, fn } of custom) {
       const value2 = fn(thing);
       if (value2) {
@@ -1459,70 +1572,71 @@ function run(async, value, reducers) {
         return index2;
       }
     }
-    if (typeof thing === "function") {
+    if (type === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-    } else if (typeof thing === "symbol") {
+    } else if (type === "symbol") {
       throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
     let str = "";
-    if (is_primitive(thing)) {
-      str = stringify_primitive(thing);
-    } else if (typeof thing.then === "function") {
+    if (type !== "object") {
+      str = stringify_primitive(type === "number" ? number : ops.toPrimitive(thing));
+    } else if (ops.isThenable(thing)) {
       if (!async) {
         throw new DevalueError(`Cannot stringify a Promise or thenable \u2014 use stringifyAsync instead`, keys, thing, value);
       }
-      str = Promise.resolve(thing).then((value2) => {
+      str = ops.toPromise(thing).then((value2) => {
         const i = flatten(value2, index2);
         if (i < 0)
           stringified[index2] = i;
       });
+      str.catch(() => {});
     } else {
-      const type = get_type(thing);
-      switch (type) {
+      const tag = ops.tagOf(thing);
+      switch (tag) {
         case "Number":
         case "String":
         case "Boolean":
         case "BigInt":
-          str = `["Object",${flatten(thing.valueOf())}]`;
+          str = `["Object",${flatten(ops.unbox(thing))}]`;
           break;
         case "Date":
-          const valid = !isNaN(thing.getDate());
-          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          str = `["Date","${ops.toISOString(thing)}"]`;
           break;
         case "URL":
-          str = `["URL",${stringify_string(thing.toString())}]`;
+          str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "URLSearchParams":
-          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+          str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "RegExp":
-          const { source, flags } = thing;
+          const { source, flags } = ops.regExpInfo(thing);
           str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
           break;
         case "Array": {
           let mostly_dense = false;
+          const length = ops.lengthOf(thing);
           str = "[";
-          for (let i = 0;i < thing.length; i += 1) {
+          for (let i = 0;i < length; i += 1) {
             if (i > 0)
               str += ",";
-            if (Object.hasOwn(thing, i)) {
+            if (ops.hasOwn(thing, i)) {
               keys.push(`[${i}]`);
-              str += flatten(thing[i]);
+              str += flatten(ops.get(thing, i));
               keys.pop();
             } else if (mostly_dense) {
               str += HOLE;
             } else {
-              const populated_keys = valid_array_indices(thing);
+              const populated_keys = ops.indicesOf(thing);
               const population = populated_keys.length;
-              const d = String(thing.length).length;
-              const hole_cost = (thing.length - population) * 3;
+              const d = String(length).length;
+              const hole_cost = (length - population) * 3;
               const sparse_cost = 4 + d + population * (d + 1);
               if (hole_cost > sparse_cost) {
-                str = "[" + SPARSE + "," + thing.length;
+                str = "[" + SPARSE + "," + length;
                 for (let j = 0;j < populated_keys.length; j++) {
                   const key = populated_keys[j];
                   keys.push(`[${key}]`);
-                  str += "," + key + "," + flatten(thing[key]);
+                  str += "," + key + "," + flatten(ops.get(thing, key));
                   keys.pop();
                 }
                 break;
@@ -1537,15 +1651,17 @@ function run(async, value, reducers) {
         }
         case "Set":
           str = '["Set"';
-          for (const value2 of thing) {
+          for (const value2 of ops.valuesOf(thing)) {
             str += `,${flatten(value2)}`;
           }
           str += "]";
           break;
         case "Map":
           str = '["Map"';
-          for (const [key, value2] of thing) {
-            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+          for (const [key, value2] of ops.entriesOf(thing)) {
+            const key_type = ops.typeOf(key);
+            const key_is_primitive = key_type !== "object" && key_type !== "function" && key_type !== "symbol";
+            keys.push(`.get(${key_is_primitive ? stringify_primitive(ops.toPrimitive(key)) : "..."})`);
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -1563,26 +1679,25 @@ function run(async, value, reducers) {
         case "Float64Array":
         case "BigInt64Array":
         case "BigUint64Array": {
-          const typedArray = thing;
-          str = '["' + type + '",' + flatten(typedArray.buffer);
-          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
-            str += `,${typedArray.byteOffset},${typedArray.length}`;
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.length}`;
           }
           str += "]";
           break;
         }
         case "DataView": {
-          const view = thing;
-          str = '["' + type + '",' + flatten(view.buffer);
-          if (view.byteLength !== view.buffer.byteLength) {
-            str += `,${view.byteOffset},${view.byteLength}`;
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.byteLength}`;
           }
           str += "]";
           break;
         }
         case "ArrayBuffer": {
-          const arraybuffer = thing;
-          const base64 = encode64(arraybuffer);
+          const base64 = encode64(ops.toArrayBuffer(thing));
           str = `["ArrayBuffer","${base64}"]`;
           break;
         }
@@ -1594,30 +1709,31 @@ function run(async, value, reducers) {
         case "Temporal.PlainMonthDay":
         case "Temporal.PlainYearMonth":
         case "Temporal.ZonedDateTime":
-          str = `["${type}",${stringify_string(thing.toString())}]`;
+          str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
           break;
-        default:
-          if (!is_plain_object(thing)) {
+        default: {
+          const shape = ops.shapeOf(thing);
+          if (shape.kind === "not-plain") {
             throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
-          if (enumerable_symbols(thing).length > 0) {
+          if (shape.kind === "symbol-keys") {
             throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
-          if (Object.getPrototypeOf(thing) === null) {
+          if (shape.kind === "null-proto") {
             str = '["null"';
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
               }
               keys.push(stringify_key(key));
-              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "]";
           } else {
             str = "{";
             let started = false;
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
               }
@@ -1625,11 +1741,12 @@ function run(async, value, reducers) {
                 str += ",";
               started = true;
               keys.push(stringify_key(key));
-              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "}";
           }
+        }
       }
     }
     stringified[index2] = str;

package/.mochi/svelte-compile/{chunk-jq7jj8jd.js → chunk-fyxcczwn.js}

@@ -2,7 +2,7 @@
 import {
   Icon,
   cookies
-} from "./chunk-gnf5cnct.js";
+} from "./chunk-en9cfkx7.js";
 
 // src/types.ts
 var CLAUDE_PERMISSION_MODES = [

package/.mochi/svelte-compile/{chunk-d2z3qxxe.js → chunk-gz27edm7.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   Icon
-} from "./chunk-gnf5cnct.js";
+} from "./chunk-en9cfkx7.js";
 
 // node_modules/@lucide/svelte/dist/icons/bot.svelte
 import"svelte/internal/flags/async";