@synapse-research/synapse 0.1.11 → 0.2.0

package/dist/node_modules/react-dom/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "react-dom",
+  "version": "19.2.3",
+  "description": "React package for working with the DOM.",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/react.git",
+    "directory": "packages/react-dom"
+  },
+  "keywords": [
+    "react"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/facebook/react/issues"
+  },
+  "homepage": "https://react.dev/",
+  "dependencies": {
+    "scheduler": "^0.27.0"
+  },
+  "peerDependencies": {
+    "react": "^19.2.3"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "client.js",
+    "client.react-server.js",
+    "index.js",
+    "profiling.js",
+    "profiling.react-server.js",
+    "react-dom.react-server.js",
+    "server.browser.js",
+    "server.bun.js",
+    "server.edge.js",
+    "server.js",
+    "server.node.js",
+    "server.react-server.js",
+    "static.browser.js",
+    "static.edge.js",
+    "static.js",
+    "static.node.js",
+    "static.react-server.js",
+    "test-utils.js",
+    "cjs/"
+  ],
+  "exports": {
+    ".": {
+      "react-server": "./react-dom.react-server.js",
+      "default": "./index.js"
+    },
+    "./client": {
+      "react-server": "./client.react-server.js",
+      "default": "./client.js"
+    },
+    "./server": {
+      "react-server": "./server.react-server.js",
+      "workerd": "./server.edge.js",
+      "bun": "./server.bun.js",
+      "deno": "./server.browser.js",
+      "worker": "./server.browser.js",
+      "node": "./server.node.js",
+      "edge-light": "./server.edge.js",
+      "browser": "./server.browser.js",
+      "default": "./server.node.js"
+    },
+    "./server.browser": {
+      "react-server": "./server.react-server.js",
+      "default": "./server.browser.js"
+    },
+    "./server.bun": {
+      "react-server": "./server.react-server.js",
+      "default": "./server.bun.js"
+    },
+    "./server.edge": {
+      "react-server": "./server.react-server.js",
+      "default": "./server.edge.js"
+    },
+    "./server.node": {
+      "react-server": "./server.react-server.js",
+      "default": "./server.node.js"
+    },
+    "./static": {
+      "react-server": "./static.react-server.js",
+      "workerd": "./static.edge.js",
+      "deno": "./static.browser.js",
+      "worker": "./static.browser.js",
+      "node": "./static.node.js",
+      "edge-light": "./static.edge.js",
+      "browser": "./static.browser.js",
+      "default": "./static.node.js"
+    },
+    "./static.browser": {
+      "react-server": "./static.react-server.js",
+      "default": "./static.browser.js"
+    },
+    "./static.edge": {
+      "react-server": "./static.react-server.js",
+      "default": "./static.edge.js"
+    },
+    "./static.node": {
+      "react-server": "./static.react-server.js",
+      "default": "./static.node.js"
+    },
+    "./profiling": {
+      "react-server": "./profiling.react-server.js",
+      "default": "./profiling.js"
+    },
+    "./test-utils": "./test-utils.js",
+    "./package.json": "./package.json"
+  },
+  "browser": {
+    "./server.js": "./server.browser.js",
+    "./static.js": "./static.browser.js"
+  }
+}

package/dist/node_modules/react-dom/server.browser.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var l, s;
+if (process.env.NODE_ENV === 'production') {
+  l = require('./cjs/react-dom-server-legacy.browser.production.js');
+  s = require('./cjs/react-dom-server.browser.production.js');
+} else {
+  l = require('./cjs/react-dom-server-legacy.browser.development.js');
+  s = require('./cjs/react-dom-server.browser.development.js');
+}
+
+exports.version = l.version;
+exports.renderToString = l.renderToString;
+exports.renderToStaticMarkup = l.renderToStaticMarkup;
+exports.renderToReadableStream = s.renderToReadableStream;
+exports.resume = s.resume;

package/dist/node_modules/react-dom/server.edge.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var b;
+var l;
+if (process.env.NODE_ENV === 'production') {
+  b = require('./cjs/react-dom-server.edge.production.js');
+  l = require('./cjs/react-dom-server-legacy.browser.production.js');
+} else {
+  b = require('./cjs/react-dom-server.edge.development.js');
+  l = require('./cjs/react-dom-server-legacy.browser.development.js');
+}
+
+exports.version = b.version;
+exports.renderToReadableStream = b.renderToReadableStream;
+exports.renderToString = l.renderToString;
+exports.renderToStaticMarkup = l.renderToStaticMarkup;
+exports.resume = b.resume;

package/dist/node_modules/react-dom/server.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./server.node');

package/dist/node_modules/react-dom/server.node.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var l, s;
+if (process.env.NODE_ENV === 'production') {
+  l = require('./cjs/react-dom-server-legacy.node.production.js');
+  s = require('./cjs/react-dom-server.node.production.js');
+} else {
+  l = require('./cjs/react-dom-server-legacy.node.development.js');
+  s = require('./cjs/react-dom-server.node.development.js');
+}
+
+exports.version = l.version;
+exports.renderToString = l.renderToString;
+exports.renderToStaticMarkup = l.renderToStaticMarkup;
+exports.renderToPipeableStream = s.renderToPipeableStream;
+exports.renderToReadableStream = s.renderToReadableStream;
+exports.resumeToPipeableStream = s.resumeToPipeableStream;
+exports.resume = s.resume;

package/dist/node_modules/react-dom/static.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./static.node');

package/dist/node_modules/react-dom/static.node.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var s;
+if (process.env.NODE_ENV === 'production') {
+  s = require('./cjs/react-dom-server.node.production.js');
+} else {
+  s = require('./cjs/react-dom-server.node.development.js');
+}
+
+exports.version = s.version;
+exports.prerenderToNodeStream = s.prerenderToNodeStream;
+exports.prerender = s.prerender;
+exports.resumeAndPrerenderToNodeStream = s.resumeAndPrerenderToNodeStream;
+exports.resumeAndPrerender = s.resumeAndPrerender;

package/dist/node_modules/regex/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "regex",
+  "version": "6.1.0",
+  "description": "Regex template tag with extended syntax, context-aware interpolation, and always-on best practices",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/regex.d.ts",
+        "default": "./dist/esm/regex.js"
+      },
+      "require": {
+        "types": "./dist/cjs/regex.d.ts",
+        "default": "./dist/cjs/regex.js"
+      }
+    },
+    "./internals": {
+      "types": "./dist/esm/internals.d.ts",
+      "import": "./src/internals.js"
+    }
+  },
+  "browser": "./dist/regex.min.js",
+  "main": "./dist/cjs/regex.js",
+  "types": "./dist/cjs/regex.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/regex.git"
+  },
+  "keywords": [
+    "regex",
+    "regexp"
+  ],
+  "dependencies": {
+    "regex-utilities": "^2.3.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "esbuild": "^0.27.1",
+    "expect-type": "^1.3.0",
+    "jasmine": "^5.13.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "bundle:global": "esbuild src/regex.js --global-name=Regex --bundle --minify --sourcemap --outfile=dist/regex.min.js",
+    "bundle:esm": "esbuild src/regex.js --format=esm --bundle --sourcemap --outfile=dist/esm/regex.js",
+    "bundle:cjs": "esbuild src/regex.js --format=cjs --bundle --sourcemap --outfile=dist/cjs/regex.js",
+    "types": "tsc src/regex.js src/internals.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outDir types",
+    "prebuild": "rm -rf dist/* types/*",
+    "build": "pnpm run bundle:global && pnpm run bundle:esm && pnpm run bundle:cjs && pnpm run types",
+    "postbuild": "node scripts/postbuild.js",
+    "pretest": "pnpm run build",
+    "test": "jasmine && tsc --project spec/types/tsconfig.test.json && attw --pack . --entrypoints ."
+  }
+}

package/dist/node_modules/regex/src/atomic.js

@@ -0,0 +1,224 @@
+import {incrementIfAtLeast, noncapturingDelim, spliceStr} from './utils-internals.js';
+import {Context, replaceUnescaped} from 'regex-utilities';
+/**
+@import {PluginData, PluginResult} from './regex.js';
+*/
+
+const atomicPluginToken = new RegExp(String.raw`(?<noncapturingStart>${noncapturingDelim})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`, 'gsu');
+
+/**
+Apply transformations for atomic groups: `(?>…)`.
+@param {string} expression
+@param {PluginData} [data]
+@returns {Required<PluginResult>}
+*/
+function atomic(expression, data) {
+  const hiddenCaptures = data?.hiddenCaptures ?? [];
+  // Capture transfer is used by <github.com/slevithan/oniguruma-to-es>
+  let captureTransfers = data?.captureTransfers ?? new Map();
+  if (!/\(\?>/.test(expression)) {
+    return {
+      pattern: expression,
+      captureTransfers,
+      hiddenCaptures,
+    };
+  }
+
+  const aGDelim = '(?>';
+  const emulatedAGDelim = '(?:(?=(';
+  const captureNumMap = [0];
+  const addedHiddenCaptures = [];
+  let numCapturesBeforeAG = 0;
+  let numAGs = 0;
+  let aGPos = NaN;
+  let hasProcessedAG;
+  do {
+    hasProcessedAG = false;
+    let numCharClassesOpen = 0;
+    let numGroupsOpenInAG = 0;
+    let inAG = false;
+    let match;
+    atomicPluginToken.lastIndex = Number.isNaN(aGPos) ? 0 : aGPos + emulatedAGDelim.length;
+    while (match = atomicPluginToken.exec(expression)) {
+      const {0: m, index, groups: {capturingStart, noncapturingStart}} = match;
+      if (m === '[') {
+        numCharClassesOpen++;
+      } else if (!numCharClassesOpen) {
+
+        if (m === aGDelim && !inAG) {
+          aGPos = index;
+          inAG = true;
+        } else if (inAG && noncapturingStart) {
+          numGroupsOpenInAG++;
+        } else if (capturingStart) {
+          if (inAG) {
+            numGroupsOpenInAG++;
+          } else {
+            numCapturesBeforeAG++;
+            captureNumMap.push(numCapturesBeforeAG + numAGs);
+          }
+        } else if (m === ')' && inAG) {
+          if (!numGroupsOpenInAG) {
+            numAGs++;
+            const addedCaptureNum = numCapturesBeforeAG + numAGs;
+            // Replace `expression` and use `<$$N>` as a temporary wrapper for the backref so it
+            // can avoid backref renumbering afterward. Wrap the whole substitution (including the
+            // lookahead and following backref) in a noncapturing group to handle following
+            // quantifiers and literal digits
+            expression = `${expression.slice(0, aGPos)}${emulatedAGDelim}${
+                expression.slice(aGPos + aGDelim.length, index)
+              }))<$$${addedCaptureNum}>)${expression.slice(index + 1)}`;
+            hasProcessedAG = true;
+            addedHiddenCaptures.push(addedCaptureNum);
+            incrementIfAtLeast(hiddenCaptures, addedCaptureNum);
+            if (captureTransfers.size) {
+              const newCaptureTransfers = new Map();
+              captureTransfers.forEach((from, to) => {
+                newCaptureTransfers.set(
+                  to >= addedCaptureNum ? to + 1 : to,
+                  from.map(f => f >= addedCaptureNum ? f + 1 : f)
+                );
+              });
+              captureTransfers = newCaptureTransfers;
+            }
+            break;
+          }
+          numGroupsOpenInAG--;
+        }
+
+      } else if (m === ']') {
+        numCharClassesOpen--;
+      }
+    }
+  // Start over from the beginning of the atomic group's contents, in case the processed group
+  // contains additional atomic groups
+  } while (hasProcessedAG);
+
+  hiddenCaptures.push(...addedHiddenCaptures);
+
+  // Second pass to adjust numbered backrefs
+  expression = replaceUnescaped(
+    expression,
+    String.raw`\\(?<backrefNum>[1-9]\d*)|<\$\$(?<wrappedBackrefNum>\d+)>`,
+    ({0: m, groups: {backrefNum, wrappedBackrefNum}}) => {
+      if (backrefNum) {
+        const bNum = +backrefNum;
+        if (bNum > captureNumMap.length - 1) {
+          throw new Error(`Backref "${m}" greater than number of captures`);
+        }
+        return `\\${captureNumMap[bNum]}`;
+      }
+      return `\\${wrappedBackrefNum}`;
+    },
+    Context.DEFAULT
+  );
+
+  return {
+    pattern: expression,
+    captureTransfers,
+    hiddenCaptures,
+  };
+}
+
+const baseQuantifier = String.raw`(?:[?*+]|\{\d+(?:,\d*)?\})`;
+// Complete tokenizer for base syntax; doesn't (need to) know about character-class-only syntax
+const possessivePluginToken = new RegExp(String.raw`
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${baseQuantifier})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g, ''), 'gsu');
+
+/**
+Transform posessive quantifiers into atomic groups. The posessessive quantifiers are:
+`?+`, `*+`, `++`, `{N}+`, `{N,}+`, `{N,N}+`.
+This follows Java, PCRE, Perl, and Python.
+Possessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.
+@param {string} expression
+@returns {PluginResult}
+*/
+function possessive(expression) {
+  if (!(new RegExp(`${baseQuantifier}\\+`).test(expression))) {
+    return {
+      pattern: expression,
+    };
+  }
+
+  const openGroupIndices = [];
+  let lastGroupIndex = null;
+  let lastCharClassIndex = null;
+  let lastToken = '';
+  let numCharClassesOpen = 0;
+  let match;
+  possessivePluginToken.lastIndex = 0;
+  while (match = possessivePluginToken.exec(expression)) {
+    const {0: m, index, groups: {qBase, qMod, invalidQ}} = match;
+    if (m === '[') {
+      if (!numCharClassesOpen) {
+        lastCharClassIndex = index;
+      }
+      numCharClassesOpen++;
+    } else if (m === ']') {
+      if (numCharClassesOpen) {
+        numCharClassesOpen--;
+      // Unmatched `]`
+      } else {
+        lastCharClassIndex = null;
+      }
+    } else if (!numCharClassesOpen) {
+
+      if (qMod === '+' && lastToken && !lastToken.startsWith('(')) {
+        // Invalid following quantifier would become valid via the wrapping group
+        if (invalidQ) {
+          throw new Error(`Invalid quantifier "${m}"`);
+        }
+        let charsAdded = -1; // -1 for removed trailing `+`
+        // Possessivizing fixed repetition quantifiers like `{2}` does't change their behavior, so
+        // avoid doing so (convert them to greedy)
+        if (/^\{\d+\}$/.test(qBase)) {
+          expression = spliceStr(expression, index + qBase.length, qMod, '');
+        } else {
+          if (lastToken === ')' || lastToken === ']') {
+            const nodeIndex = lastToken === ')' ? lastGroupIndex : lastCharClassIndex;
+            // Unmatched `)` would break out of the wrapping group and mess with handling.
+            // Unmatched `]` wouldn't be a problem, but it's unnecessary to have dedicated support
+            // for unescaped `]++` since this won't work with flag u or v anyway
+            if (nodeIndex === null) {
+              throw new Error(`Invalid unmatched "${lastToken}"`);
+            }
+            expression = `${expression.slice(0, nodeIndex)}(?>${expression.slice(nodeIndex, index)}${qBase})${expression.slice(index + m.length)}`;
+          } else {
+            expression = `${expression.slice(0, index - lastToken.length)}(?>${lastToken}${qBase})${expression.slice(index + m.length)}`;
+          }
+          charsAdded += 4; // `(?>)`
+        }
+        possessivePluginToken.lastIndex += charsAdded;
+      } else if (m[0] === '(') {
+        openGroupIndices.push(index);
+      } else if (m === ')') {
+        lastGroupIndex = openGroupIndices.length ? openGroupIndices.pop() : null;
+      }
+
+    }
+    lastToken = m;
+  }
+
+  return {
+    pattern: expression,
+  };
+}
+
+export {
+  atomic,
+  possessive,
+};

package/dist/node_modules/regex/src/internals.js

@@ -0,0 +1,2 @@
+export {atomic, possessive} from './atomic.js';
+export {RegExpSubclass} from './subclass.js';

package/dist/node_modules/regex/src/subclass.js

@@ -0,0 +1,98 @@
+/**
+Works the same as JavaScript's native `RegExp` constructor in all contexts, but automatically
+adjusts subpattern matches and indices (with flag `d`) to account for captures added as part of
+emulating extended syntax.
+*/
+class RegExpSubclass extends RegExp {
+  // Avoid `#private` to allow for subclassing
+  /**
+  @private
+  @type {Map<number, {
+    hidden: true;
+  }>}
+  */
+  _captureMap;
+  /**
+  @overload
+  @param {string} expression
+  @param {string} [flags]
+  @param {{
+    hiddenCaptures?: Array<number>;
+  }} [options]
+  */
+  /**
+  @overload
+  @param {RegExpSubclass} expression
+  @param {string} [flags]
+  */
+  constructor(expression, flags, options) {
+    // Argument `options` isn't provided when regexes are copied via `new RegExpSubclass(regexp)`,
+    // including as part of the internal handling of string methods `matchAll` and `split`
+    if (expression instanceof RegExp) {
+      if (options) {
+        throw new Error('Cannot provide options when copying a regexp');
+      }
+      super(expression, flags);
+      if (expression instanceof RegExpSubclass) {
+        this._captureMap = expression._captureMap;
+      } else {
+        this._captureMap = new Map();
+      }
+    } else {
+      super(expression, flags);
+      const hiddenCaptures = options?.hiddenCaptures ?? [];
+      this._captureMap = createCaptureMap(hiddenCaptures);
+    }
+  }
+  /**
+  Called internally by all String/RegExp methods that use regexes.
+  @override
+  @param {string} str
+  @returns {RegExpExecArray | null}
+  */
+  exec(str) {
+    const match = super.exec(str);
+    if (!match || !this._captureMap.size) {
+      return match;
+    }
+    const matchCopy = [...match];
+    // Empty all but the first value of the array while preserving its other properties
+    match.length = 1;
+    let indicesCopy;
+    if (this.hasIndices) {
+      indicesCopy = [...match.indices];
+      match.indices.length = 1;
+    }
+    for (let i = 1; i < matchCopy.length; i++) {
+      if (!this._captureMap.get(i)?.hidden) {
+        match.push(matchCopy[i]);
+        if (this.hasIndices) {
+          match.indices.push(indicesCopy[i]);
+        }
+      }
+    }
+    return match;
+  }
+}
+
+/**
+Build the capturing group map, with hidden captures marked to indicate their submatches shouldn't
+appear in match results.
+@param {Array<number>} hiddenCaptures
+@returns {Map<number, {
+  hidden: true;
+}>}
+*/
+function createCaptureMap(hiddenCaptures) {
+  const captureMap = new Map();
+  for (const num of hiddenCaptures) {
+    captureMap.set(num, {
+      hidden: true,
+    });
+  }
+  return captureMap;
+}
+
+export {
+  RegExpSubclass,
+};

package/dist/node_modules/regex/src/utils-internals.js

@@ -0,0 +1,33 @@
+// Separating some utils for improved tree shaking of the `./internals` export
+
+const noncapturingDelim = String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;
+
+/**
+Updates the array in place by incrementing each value greater than or equal to the threshold.
+@param {Array<number>} arr
+@param {number} threshold
+*/
+function incrementIfAtLeast(arr, threshold) {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= threshold) {
+      arr[i]++;
+    }
+  }
+}
+
+/**
+@param {string} str
+@param {number} pos
+@param {string} oldValue
+@param {string} newValue
+@returns {string}
+*/
+function spliceStr(str, pos, oldValue, newValue) {
+  return str.slice(0, pos) + newValue + str.slice(pos + oldValue.length);
+}
+
+export {
+  incrementIfAtLeast,
+  noncapturingDelim,
+  spliceStr,
+};

package/dist/node_modules/regex-recursion/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "regex-recursion",
+  "version": "6.0.2",
+  "description": "Recursive matching plugin for Regex+",
+  "author": "Steven Levithan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/index.js"
+    }
+  },
+  "browser": "./dist/regex-recursion.min.js",
+  "types": "./types/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slevithan/regex-recursion.git"
+  },
+  "keywords": [
+    "recursion",
+    "regex",
+    "regexp"
+  ],
+  "dependencies": {
+    "regex-utilities": "^2.3.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.2",
+    "jasmine": "^5.5.0",
+    "regex": "^6.0.1",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "bundle:global": "esbuild src/index.js --global-name=Regex.plugins --bundle --minify --sourcemap --outfile=dist/regex-recursion.min.js",
+    "types": "tsc src/index.js --rootDir src --declaration --allowJs --emitDeclarationOnly --outDir types",
+    "prebuild": "rm -rf dist/* types/*",
+    "build": "pnpm run bundle:global && pnpm run types",
+    "pretest": "pnpm run build",
+    "test": "jasmine"
+  }
+}