@openclaw/matrix 2026.8.1-beta.2 → 2026.8.1

package/node_modules/markdown-it/node_modules/entities/src/internal/encode-shared.ts

@@ -0,0 +1,123 @@
+/**
+ * A node inside the encoding trie used by `encode.ts`.
+ *
+ * There are two physical shapes to minimize allocations and lookup cost:
+ *
+ * 1. Leaf node (string)
+ *    - A plain string (already in the form `"&name;"`).
+ *    - Represents a terminal match with no children.
+ *
+ * 2. Branch / value node (object)
+ */
+export type EncodeTrieNode =
+    | string
+    | {
+          /**
+           * Entity value for the current code point sequence (wrapped: `&...;`).
+           * Present when the path to this node itself is a valid named entity.
+           */
+          value: string | undefined;
+          /** If a number, the next code unit of the only next character. */
+          next: number | Map<number, EncodeTrieNode>;
+          /** If next is a number, `nextValue` contains the entity value. */
+          nextValue?: string;
+      };
+
+/**
+ * Parse a compact encode trie string into a Map structure used for encoding.
+ *
+ * Format per entry (ascending code points using delta encoding):
+ *   <diffBase36>[&name;][{<children>}]  -- diff omitted when 0
+ * Where diff = currentKey - previousKey - 1 (first entry stores absolute key).
+ * `&name;` is the entity value (already wrapped); a following `{` denotes children.
+ * @param serialized Serialized text fragment to encode.
+ */
+export function parseEncodeTrie(
+    serialized: string,
+): Map<number, EncodeTrieNode> {
+    const top = new Map<number, EncodeTrieNode>();
+    const totalLength = serialized.length;
+    let cursor = 0;
+    let lastTopKey = -1;
+
+    function readDiff(): number {
+        const start = cursor;
+        while (cursor < totalLength) {
+            const char = serialized.charAt(cursor);
+
+            if ((char < "0" || char > "9") && (char < "a" || char > "z")) {
+                break;
+            }
+            cursor++;
+        }
+        if (cursor === start) return 0;
+        return Number.parseInt(serialized.slice(start, cursor), 36);
+    }
+
+    function readEntity(): string {
+        if (serialized[cursor] !== "&") {
+            throw new Error(`Child entry missing value near index ${cursor}`);
+        }
+
+        // Cursor currently points at '&'
+        const start = cursor;
+        const end = serialized.indexOf(";", cursor + 1);
+        if (end === -1) {
+            throw new Error(`Unterminated entity starting at index ${start}`);
+        }
+        cursor = end + 1; // Move past ';'
+        return serialized.slice(start, cursor); // Includes & ... ;
+    }
+
+    while (cursor < totalLength) {
+        const keyDiff = readDiff();
+        const key = lastTopKey === -1 ? keyDiff : lastTopKey + keyDiff + 1;
+
+        let value: string | undefined;
+        if (serialized[cursor] === "&") value = readEntity();
+
+        if (serialized[cursor] === "{") {
+            cursor++; // Skip '{'
+            // Parse first child
+            let diff = readDiff();
+            let childKey = diff; // First key (lastChildKey = -1)
+            const firstValue = readEntity();
+            if (serialized[cursor] === "{") {
+                throw new Error("Unexpected nested '{' beyond depth 2");
+            }
+            // If end of block -> single child optimization
+            if (serialized[cursor] === "}") {
+                top.set(key, { value, next: childKey, nextValue: firstValue });
+                cursor++; // Skip '}'
+            } else {
+                const childMap = new Map<number, EncodeTrieNode>([
+                    [childKey, firstValue],
+                ]);
+                let lastChildKey = childKey;
+                while (cursor < totalLength && serialized[cursor] !== "}") {
+                    diff = readDiff();
+                    childKey = lastChildKey + diff + 1;
+                    const childValue = readEntity();
+                    if (serialized[cursor] === "{") {
+                        throw new Error("Unexpected nested '{' beyond depth 2");
+                    }
+                    childMap.set(childKey, childValue);
+                    lastChildKey = childKey;
+                }
+                if (serialized[cursor] !== "}") {
+                    throw new Error("Unterminated child block");
+                }
+                cursor++; // Skip '}'
+                top.set(key, { value, next: childMap });
+            }
+        } else if (value === undefined) {
+            throw new Error(
+                `Malformed encode trie: missing value at index ${cursor}`,
+            );
+        } else {
+            top.set(key, value);
+        }
+        lastTopKey = key;
+    }
+    return top;
+}

package/node_modules/markdown-it/node_modules/linkify-it/README.md

@@ -24,65 +24,39 @@ Install
 npm install linkify-it --save
 ```
 
-Browserification is also supported.
-
 
 Usage examples
 --------------
 
-##### Example 1
-
 ```js
-import linkifyit from 'linkify-it';
-const linkify = linkifyit();
+import { LinkifyIt } from 'linkify-it';
+const linkify = new LinkifyIt({ fuzzyLink: true });
 
-// Reload full tlds list & add unofficial `.onion` domain.
 linkify
-  .tlds(require('tlds'))          // Reload with full tlds list
-  .tlds('onion', true)            // Add unofficial `.onion` domain
-  .add('git:', 'http:')           // Add `git:` protocol as "alias"
-  .add('ftp:', null)              // Disable `ftp:` protocol
-  .set({ fuzzyIP: true });        // Enable IPs in fuzzy links (without schema)
-
-console.log(linkify.test('Site github.com!'));  // true
-
-console.log(linkify.match('Site github.com!')); // [ {
-                                                //   schema: "",
-                                                //   index: 5,
-                                                //   lastIndex: 15,
-                                                //   raw: "github.com",
-                                                //   text: "github.com",
-                                                //   url: "http://github.com",
-                                                // } ]
+  .tlds(require('tlds'))
+  .tlds('onion', true)
+  .add('ftp:', null)
+  .set({ fuzzyIP: true });
+
+console.log(linkify.test('Site github.com!'));
+// true
+
+console.log(linkify.match('Site github.com!'));
+// [ {
+//   schema: "",
+//   index: 5,
+//   lastIndex: 15,
+//   raw: "github.com",
+//   text: "github.com",
+//   url: "http://github.com",
+// } ]
 ```
 
-##### Example 2. Add twitter mentions handler
+See more in examples folder:
 
-```js
-linkify.add('@', {
-  validate: function (text, pos, self) {
-    const tail = text.slice(pos);
-
-    if (!self.re.twitter) {
-      self.re.twitter =  new RegExp(
-        `^([a-zA-Z0-9_]){1,15}(?!_)(?=$|${self.re.src_ZPCc})`
-      );
-    }
-    if (self.re.twitter.test(tail)) {
-      // Linkifier allows punctuation chars before prefix,
-      // but we additionally disable `@` ("@@mention" is invalid)
-      if (pos >= 2 && tail[pos - 2] === '@') {
-        return false;
-      }
-      return tail.match(self.re.twitter)[0].length;
-    }
-    return 0;
-  },
-  normalize: function (match) {
-    match.url = `https://twitter.com/${match.url.replace(/^@/, '')}`;
-  }
-});
-```
+- [twitter mentions](examples/twitter.mjs)
+- [CJK paired brackets in URL paths](examples/cjk-paired-brackets.mjs)
+- [increased nested scopes depth](examples/nested-scopes-depth.mjs)
 
 
 API
@@ -90,39 +64,28 @@ API
 
 __[API documentation](http://markdown-it.github.io/linkify-it/doc)__
 
-### new LinkifyIt(schemas, options)
+### new LinkifyIt(options)
 
-Creates new linkifier instance with optional additional schemas.
-Can be called without `new` keyword for convenience.
+Creates new linkifier instance.
 
 By default understands:
 
 - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
-- "fuzzy" links and emails (google.com, foo@bar.com).
-
-`schemas` is an object, where each key/value describes protocol/rule:
-
-- __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
-  for example). `linkify-it` makes sure that prefix is not preceded with
-  alphanumeric char.
-- __value__ - rule to check tail after link prefix
-  - _String_ - just alias to existing rule
-  - _Object_
-    - _validate_ - either a `RegExp` (start with `^`, and don't include the
-      link prefix itself), or a validator function which, given arguments
-      _text_, _pos_, and _self_, returns the length of a match in _text_
-      starting at index _pos_.  _pos_ is the index right after the link prefix.
-      _self_ can be used to access the linkify object to cache data.
-    - _normalize_ - optional function to normalize text & url of matched result
-      (for example, for twitter mentions).
+- "fuzzy" emails (foo@bar.com).
 
 `options`:
 
-- __fuzzyLink__ - recognize URL-s without `http(s)://` head. Default `true`.
+- __fuzzyLink__ - recognize URL-s without `http(s)://` head. Default `false`.
 - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts
   like version numbers. Default `false`.
 - __fuzzyEmail__ - recognize emails without `mailto:` prefix. Default `true`.
+- __tlds__ - allowed TLDs list for fuzzy links. Replaces the default list
+  when set.
 - __---__ - set `true` to terminate link with `---` (if it's considered as long dash).
+  Default `false`.
+- __rebuilder__ - custom `REBuilder` instance for patched regex fragments.
+- __urlAuth__ - recognize authentication data in URLs. Default `false`.
+- __maxLength__ - maximum link length. Default `10000`.
 
 
 ### .test(text)
@@ -130,13 +93,6 @@ By default understands:
 Searches linkifiable pattern and returns `true` on success or `false` on fail.
 
 
-### .pretest(text)
-
-Quick check if link MAY BE can exist. Can be used to optimize more expensive
-`.test()` calls. Return `false` if link can not be found, `true` - if `.test()`
-call needed to know exactly.
-
-
 ### .testSchemaAt(text, name, offset)
 
 Similar to `.test()` but checks only specific protocol tail exactly at given
@@ -178,18 +134,25 @@ If that's not enough, you can reload defaults with more detailed zones list.
 
 ### .add(key, value)
 
-Add a new schema to the schemas object.  As described in the constructor
-definition, `key` is a link prefix (`skype:`, for example), and `value`
-is a String to alias to another schema, or an Object with `validate` and
-optionally `normalize` definitions.  To disable an existing rule, use
-`.add(key, null)`.
+Add a new schema to the schemas object.
 
+`key` is a link prefix (usually, protocol name with `:` at the end, `skype:`
+for example). `linkify-it` makes sure that prefix is not preceded with
+alphanumeric char.
 
-### .set(options)
+`value` is a rule to check tail after link prefix:
 
-Override default options. Missed properties will not be changed.
+- _Object_
+  - _validate_ - validator function which, given arguments _text_, _pos_, and
+    _self_, returns the length of a match in _text_ starting at index _pos_.
+    _pos_ is the index right after the link prefix. _self_ can be used to
+    access the linkify object to cache data.
+  - _normalize_ - optional function to normalize text & url of matched result
+    (for example, for twitter mentions).
 
+To disable an existing rule, use `.add(key, null)`.
 
-## License
 
-[MIT](https://github.com/markdown-it/linkify-it/blob/master/LICENSE)
+### .set(options)
+
+Override default options. Missed properties will not be changed.