Merge branch 'main' into tsgo

Author: iuioiua

.github/labeler.yml

@@ -7,6 +7,9 @@ async:
 bytes:
   - changed-files:
       - any-glob-to-any-file: bytes/**
+cache:
+  - changed-files:
+      - any-glob-to-any-file: cache/**
 cbor:
   - changed-files:
       - any-glob-to-any-file: cbor/**
@@ -115,6 +118,9 @@ uuid:
 webgpu:
   - changed-files:
       - any-glob-to-any-file: webgpu/**
+xml:
+  - changed-files:
+      - any-glob-to-any-file: xml/**
 yaml:
   - changed-files:
       - any-glob-to-any-file: yaml/**

.github/workflows/title.yml

@@ -76,4 +76,5 @@ jobs:
             ulid(/unstable)?
             uuid(/unstable)?
             webgpu(/unstable)?
+            xml(/unstable)?
             yaml(/unstable)?

Releases.md

@@ -1,3 +1,62 @@
+### 2026.02.20
+
+#### @std/assert 1.0.19 (patch)
+
+- fix(assert): preserve Date instances in assertObjectMatch filter (#6988)
+- docs(assert): add a note about unreliable equality (#6989)
+
+#### @std/async 1.2.0 (minor)
+
+- feat(async): stabilize abort signal support in retry (#6968)
+- feat(async/unstable): add `Lazy` for once-only async init (#7007)
+- feat(async/unstable): allow `AbortableOptions` with optional signal in
+  `abortable` (#6971)
+- feat(async/unstable): add poll function (#6973)
+- feat(async/unstable): add allKeyed and allSettledKeyed (#6959)
+- refactor(async/unstable): apply style guide to circuit breaker (#7008)
+- refactor(async/unstable): make circuit breaker resilient to throwing callbacks
+  (#6996)
+
+#### @std/cli 1.0.28 (patch)
+
+- feat(cli/unstable): introduce StaticLine (#6758)
+- fix(cli): handle empty value in parseArgs (#6995)
+- fix(cli): prevent prototype pollution in parseArgs (#6980)
+
+#### @std/collections 1.1.6 (patch)
+
+- fix(collections): stricter enforcement on generics (#6961)
+
+#### @std/expect 1.0.18 (patch)
+
+- feat(expect/unstable): implement toMatchSnapshot() (#7003)
+
+#### @std/fs 1.0.23 (patch)
+
+- fix(fs/unstable): use crypto.getRandomValues() for temp file naming (#6983)
+
+#### @std/http 1.0.25 (patch)
+
+- feat(http/unstable): add `Cache-Control` header parser and formatter (#7005)
+- feat(http/unstable): implement RFC 9651 Structured Field Values (#6963)
+- fix(http): guard top-level Deno global access for browser compatibility
+  (#6987)
+- refactor(http/unstable): improve route() method matching (#6990)
+
+#### @std/json 1.0.3 (patch)
+
+- feat(json/unstable): implement RFC 8785 JSON canonicalization (#6965)
+
+#### @std/xml 0.1.0 (minor)
+
+- feat(xml/unstable): add XML parsing and serialization module (#6981)
+- docs(xml): clean up JSDoc and error message style (#7009)
+- refactor(xml): improve tokenizer edge cases and performance (#6997)
+
+#### @std/yaml 1.0.12 (patch)
+
+- refactor(yaml): add `Scanner` class (#6958)
+
 ### 2026.01.30
 
 #### @std/assert 1.0.18 (patch)

_tools/check_docs.ts

@@ -30,8 +30,8 @@ type DocNodeWithJsDoc<T = DocNodeBase> = T & {
   jsDoc: JsDoc;
 };
 
-const TS_SNIPPET = /```ts[\s\S]*?```/g;
-const ASSERTION_IMPORT =
+const TS_SNIPPET_REGEXP = /```ts[\s\S]*?```/g;
+const ASSERTION_IMPORT_REGEXP =
   /from "@std\/(assert(\/[a-z-]+)?|expect(\/[a-z-]+)?|testing\/(mock|snapshot|types))"/g;
 const NEWLINE = "\n";
 const diagnostics: DocumentError[] = [];
@@ -142,7 +142,7 @@ function assertHasSnippets(
   doc: string,
   document: { jsDoc: JsDoc; location: Location },
 ) {
-  const snippets = doc.match(TS_SNIPPET);
+  const snippets = doc.match(TS_SNIPPET_REGEXP);
   assert(
     snippets !== null,
     "@example tag must have a TypeScript code snippet",
@@ -155,7 +155,7 @@ function assertHasSnippets(
     snippet = snippet.split(NEWLINE).slice(1, -1).join(NEWLINE);
     if (!(delim?.includes("no-assert") || delim?.includes("ignore"))) {
       assert(
-        snippet.match(ASSERTION_IMPORT) !== null,
+        snippet.match(ASSERTION_IMPORT_REGEXP) !== null,
         "Snippet must contain assertion from `@std/assert`, `@std/expect` or `@std/testing`",
         document,
       );

_tools/lint_plugin.ts

@@ -11,9 +11,10 @@ import { toFileUrl } from "@std/path/to-file-url";
 import { resolve } from "@std/path/resolve";
 
 const PASCAL_CASE_REGEXP = /^_?(?:[A-Z][a-z0-9]*)*_?$/;
-const UPPER_CASE_ONLY = /^_?[A-Z]{2,}$/;
+const UPPER_CASE_ONLY_REGEXP = /^_?[A-Z]{2,}$/;
 function isPascalCase(string: string): boolean {
-  return PASCAL_CASE_REGEXP.test(string) && !UPPER_CASE_ONLY.test(string);
+  return PASCAL_CASE_REGEXP.test(string) &&
+    !UPPER_CASE_ONLY_REGEXP.test(string);
 }
 
 const CAMEL_CASE_REGEXP = /^[_a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*_?$/;
@@ -233,6 +234,38 @@ export default {
               if (id.type !== "Identifier") return;
               const name = id.name;
               if (!name) return;
+              if (isConstantCase(name)) {
+                if (
+                  declaration.init?.type === "NewExpression" &&
+                  declaration.init.callee.type === "Identifier"
+                ) {
+                  switch (declaration.init.callee.name) {
+                    case "RegExp": {
+                      if (name !== "REGEXP" && !name.endsWith("_REGEXP")) {
+                        context.report({
+                          node: id,
+                          message:
+                            `RegExp variable name '${name}' must end with _REGEXP.`,
+                          fix: (fixer) =>
+                            fixer.replaceText(id, `${name}_REGEXP`),
+                        });
+                      }
+                      break;
+                    }
+                  }
+                } else if (
+                  declaration.init?.type === "Literal" &&
+                  declaration.init.value instanceof RegExp &&
+                  name !== "REGEXP" && !name.endsWith("_REGEXP")
+                ) {
+                  context.report({
+                    node: id,
+                    message:
+                      `RegExp variable name '${name}' must end with _REGEXP.`,
+                    fix: (fixer) => fixer.replaceText(id, `${name}_REGEXP`),
+                  });
+                }
+              }
               if (
                 !isConstantCase(name) && !isCamelCase(name) &&
                 !isPascalCase(name)

_tools/node_test_runner/tsconfig_for_bun.json

@@ -10,7 +10,8 @@
       "@std/internal/os": ["./internal/os.ts"],
       "@std/internal/styles": ["./internal/styles.ts"],
       "@std/path": ["./path/mod.ts"],
-      "@std/semver": ["./semver/mod.ts"]
+      "@std/semver": ["./semver/mod.ts"],
+      "@std/testing/types": ["./testing/types.ts"]
     }
   }
 }

assert/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@std/assert",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "exports": {
     ".": "./mod.ts",
     "./assert": "./assert.ts",

assert/equal.ts

@@ -89,10 +89,18 @@ function sameValueZero(a: unknown, b: unknown) {
 /**
  * Deep equality comparison used in assertions.
  *
+ * This function is based on value equality, but for some cases (such as data
+ * that can only be read asynchronously or function properties) value equality
+ * is not possible to determine. In such cases, reference equality is used
+ * instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
  * @param a The actual value
  * @param b The expected value
  * @returns `true` if the values are deeply equal, `false` otherwise
  *
+ * @throws {TypeError} If either value is a `WeakMap` or `WeakSet`.
+ *
  * @example Usage
  * ```ts
  * import { equal } from "@std/assert/equal";

assert/equals.ts

@@ -15,9 +15,11 @@ import { AssertionError } from "./assertion_error.ts";
  * Type parameter can be specified to ensure values under comparison have the
  * same type.
  *
- * Note: When comparing `Blob` objects, you should first convert them to
- * `Uint8Array` using the `Blob.bytes()` method and then compare their
- * contents.
+ * Note: This function is based on value equality, but for some cases (such as
+ * data that can only be read asynchronously or function properties) value
+ * equality is not possible to determine. In such cases, reference equality is
+ * used instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
  *
  * @example Usage
  * ```ts ignore

assert/not_equals.ts

@@ -11,6 +11,12 @@ import { format } from "@std/internal/format";
  *
  * Type parameter can be specified to ensure values under comparison have the same type.
  *
+ * Note: This function is based on value equality, but for some cases (such as
+ * data that can only be read asynchronously or function properties) value
+ * equality is not possible to determine. In such cases, reference equality is
+ * used instead, which may cause false negatives for objects such as `Blob`s or
+ * `Request`s.
+ *
  * @example Usage
  * ```ts ignore
  * import { assertNotEquals } from "@std/assert";