@bolt-foundry/gambit-core 0.5.3-dev

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,12 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,15 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+export {};

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,61 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/deps/jsr.io/@std/collections/1.1.3/_utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Filters the given array, removing all elements that do not match the given predicate
+ * **in place. This means `array` will be modified!**.
+ */
+export declare function filterInPlace<T>(array: Array<T>, predicate: (el: T) => boolean): Array<T>;
+//# sourceMappingURL=_utils.d.ts.map

package/esm/deps/jsr.io/@std/collections/1.1.3/_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.1.3/_utils.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,OAAO,GAC5B,KAAK,CAAC,CAAC,CAAC,CAeV"}

package/esm/deps/jsr.io/@std/collections/1.1.3/_utils.js

@@ -0,0 +1,18 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Filters the given array, removing all elements that do not match the given predicate
+ * **in place. This means `array` will be modified!**.
+ */
+export function filterInPlace(array, predicate) {
+    let outputIndex = 0;
+    for (const cur of array) {
+        if (!predicate(cur)) {
+            continue;
+        }
+        array[outputIndex] = cur;
+        outputIndex += 1;
+    }
+    array.splice(outputIndex);
+    return array;
+}

package/esm/deps/jsr.io/@std/collections/1.1.3/deep_merge.d.ts

@@ -0,0 +1,322 @@
+/**
+ * Merges the two given records, recursively merging any nested records with the
+ * second collection overriding the first in case of conflict.
+ *
+ * For arrays, maps and sets, a merging strategy can be specified to either
+ * `replace` values, or `merge` them instead.
+ *
+ * @typeParam T Type of the first record
+ *
+ * @param record First record to merge.
+ * @param other Second record to merge.
+ * @param options Merging options.
+ *
+ * @returns A new record with the merged values.
+ *
+ * @example Merge objects
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: true };
+ * const b = { foo: { bar: true } };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: { bar: true } };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge arrays
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: [1, 2, 3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge maps
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Map([["a", 1]]) };
+ * const b = { foo: new Map([["b", 2]]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Map([["a", 1], ["b", 2]]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge sets
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Set([1]) };
+ * const b = { foo: new Set([2]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Set([1, 2]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge with custom options
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b, { arrays: "replace" });
+ *
+ * const expected = { foo: [3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ */
+export declare function deepMerge<T extends Record<PropertyKey, unknown>>(record: Partial<Readonly<T>>, other: Partial<Readonly<T>>, options?: Readonly<DeepMergeOptions>): T;
+/**
+ * Merges the two given records, recursively merging any nested records with the
+ * second collection overriding the first in case of conflict.
+ *
+ * For arrays, maps and sets, a merging strategy can be specified to either
+ * `replace` values, or `merge` them instead.
+ *
+ * @typeParam T Type of the first record
+ * @typeParam U Type of the second record
+ * @typeParam Options Merging options
+ *
+ * @param record First record to merge.
+ * @param other Second record to merge.
+ * @param options Merging options.
+ *
+ * @returns A new record with the merged values.
+ *
+ * @example Merge objects
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: true };
+ * const b = { foo: { bar: true } };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: { bar: true } };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge arrays
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: [1, 2, 3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge maps
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Map([["a", 1]]) };
+ * const b = { foo: new Map([["b", 2]]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Map([["a", 1], ["b", 2]]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge sets
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: new Set([1]) };
+ * const b = { foo: new Set([2]) };
+ *
+ * const result = deepMerge(a, b);
+ *
+ * const expected = { foo: new Set([1, 2]) };
+ *
+ * assertEquals(result, expected);
+ * ```
+ *
+ * @example Merge with custom options
+ * ```ts
+ * import { deepMerge } from "@std/collections/deep-merge";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = { foo: [1, 2] };
+ * const b = { foo: [3, 4] };
+ *
+ * const result = deepMerge(a, b, { arrays: "replace" });
+ *
+ * const expected = { foo: [3, 4] };
+ *
+ * assertEquals(result, expected);
+ * ```
+ */
+export declare function deepMerge<T extends Record<PropertyKey, unknown>, U extends Record<PropertyKey, unknown>, Options extends DeepMergeOptions>(record: Readonly<T>, other: Readonly<U>, options?: Readonly<Options>): DeepMerge<T, U, Options>;
+/** Merging strategy */
+export type MergingStrategy = "replace" | "merge";
+/** Options for {@linkcode deepMerge}. */
+export type DeepMergeOptions = {
+    /**
+     * Merging strategy for arrays
+     *
+     * @default {"merge"}
+     */
+    arrays?: MergingStrategy;
+    /**
+     * Merging strategy for maps.
+     *
+     * @default {"merge"}
+     */
+    maps?: MergingStrategy;
+    /**
+     * Merging strategy for sets.
+     *
+     * @default {"merge"}
+     */
+    sets?: MergingStrategy;
+};
+/**
+ * How does recursive typing works ?
+ *
+ * Deep merging process is handled through `DeepMerge<T, U, Options>` type.
+ * If both T and U are Records, we recursively merge them,
+ * else we treat them as primitives.
+ *
+ * Merging process is handled through `Merge<T, U>` type, in which
+ * we remove all maps, sets, arrays and records so we can handle them
+ * separately depending on merging strategy:
+ *
+ *    Merge<
+ *      {foo: string},
+ *      {bar: string, baz: Set<unknown>},
+ *    > // "foo" and "bar" will be handled with `MergeRightOmitComplexes`
+ *      // "baz" will be handled with `MergeAll*` type
+ *
+ * `MergeRightOmitComplexes<T, U>` will do the above: all T's
+ * exclusive keys will be kept, though common ones with U will have their
+ * typing overridden instead:
+ *
+ *    MergeRightOmitComplexes<
+ *      {foo: string, baz: number},
+ *      {foo: boolean, bar: string}
+ *    > // {baz: number, foo: boolean, bar: string}
+ *      // "baz" was kept from T
+ *      // "foo" was overridden by U's typing
+ *      // "bar" was added from U
+ *
+ * For Maps, Arrays, Sets and Records, we use `MergeAll*<T, U>` utility
+ * types. They will extract relevant data structure from both T and U
+ * (providing that both have same data data structure, except for typing).
+ *
+ * From these, `*ValueType<T>` will extract values (and keys) types to be
+ * able to create a new data structure with an union typing from both
+ * data structure of T and U:
+ *
+ *    MergeAllSets<
+ *      {foo: Set<number>},
+ *      {foo: Set<string>}
+ *    > // `SetValueType` will extract "number" for T
+ *      // `SetValueType` will extract "string" for U
+ *      // `MergeAllSets` will infer type as Set<number|string>
+ *      // Process is similar for Maps, Arrays, and Sets
+ *
+ * `DeepMerge<T, U, Options>` is taking a third argument to be handle to
+ * infer final typing depending on merging strategy:
+ *
+ *    & (Options extends { sets: "replace" } ? PartialByType<U, Set<unknown>>
+ *      : MergeAllSets<T, U>)
+ *
+ * In the above line, if "Options" have its merging strategy for Sets set to
+ * "replace", instead of performing merging of Sets type, it will take the
+ * typing from right operand (U) instead, effectively replacing the typing.
+ *
+ * An additional note, we use `ExpandRecursively<T>` utility type to expand
+ * the resulting typing and hide all the typing logic of deep merging so it is
+ * more user friendly.
+ */
+/** Force intellisense to expand the typing to hide merging typings */
+export type ExpandRecursively<T> = T extends Record<PropertyKey, unknown> ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+/** Filter of keys matching a given type */
+export type PartialByType<T, U> = {
+    [K in keyof T as T[K] extends U ? K : never]: T[K];
+};
+/** Get set values type */
+export type SetValueType<T> = T extends Set<infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllSets<T, U, X = PartialByType<T, Set<unknown>>, Y = PartialByType<U, Set<unknown>>, Z = {
+    [K in keyof X & keyof Y]: Set<SetValueType<X[K]> | SetValueType<Y[K]>>;
+}> = Z;
+/** Get array values type */
+export type ArrayValueType<T> = T extends Array<infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllArrays<T, U, X = PartialByType<T, Array<unknown>>, Y = PartialByType<U, Array<unknown>>, Z = {
+    [K in keyof X & keyof Y]: Array<ArrayValueType<X[K]> | ArrayValueType<Y[K]>>;
+}> = Z;
+/** Get map values types */
+export type MapKeyType<T> = T extends Map<infer K, unknown> ? K : never;
+/** Get map values types */
+export type MapValueType<T> = T extends Map<unknown, infer V> ? V : never;
+/** Merge all sets types definitions from keys present in both objects */
+export type MergeAllMaps<T, U, X = PartialByType<T, Map<unknown, unknown>>, Y = PartialByType<U, Map<unknown, unknown>>, Z = {
+    [K in keyof X & keyof Y]: Map<MapKeyType<X[K]> | MapKeyType<Y[K]>, MapValueType<X[K]> | MapValueType<Y[K]>>;
+}> = Z;
+/** Merge all records types definitions from keys present in both objects */
+export type MergeAllRecords<T, U, Options, X = PartialByType<T, Record<PropertyKey, unknown>>, Y = PartialByType<U, Record<PropertyKey, unknown>>, Z = {
+    [K in keyof X & keyof Y]: DeepMerge<X[K], Y[K], Options>;
+}> = Z;
+/** Exclude map, sets and array from type */
+export type OmitComplexes<T> = Omit<T, keyof PartialByType<T, Map<unknown, unknown> | Set<unknown> | Array<unknown> | Record<PropertyKey, unknown>>>;
+/** Object with keys in either T or U but not in both */
+export type ObjectXorKeys<T, U, X = Omit<T, keyof U> & Omit<U, keyof T>, Y = {
+    [K in keyof X]: X[K];
+}> = Y;
+/** Merge two objects, with left precedence */
+export type MergeRightOmitComplexes<T, U, X = ObjectXorKeys<T, U> & OmitComplexes<{
+    [K in keyof U]: U[K];
+}>> = X;
+/** Merge two objects */
+export type Merge<T, U, Options, X = MergeRightOmitComplexes<T, U> & MergeAllRecords<T, U, Options> & (Options extends {
+    sets: "replace";
+} ? PartialByType<U, Set<unknown>> : MergeAllSets<T, U>) & (Options extends {
+    arrays: "replace";
+} ? PartialByType<U, Array<unknown>> : MergeAllArrays<T, U>) & (Options extends {
+    maps: "replace";
+} ? PartialByType<U, Map<unknown, unknown>> : MergeAllMaps<T, U>)> = ExpandRecursively<X>;
+/** Merge deeply two objects */
+export type DeepMerge<T, U, Options = Record<string, MergingStrategy>> = [
+    T,
+    U
+] extends [Record<PropertyKey, unknown>, Record<PropertyKey, unknown>] ? Merge<T, U, Options> : T | U;
+//# sourceMappingURL=deep_merge.d.ts.map

package/esm/deps/jsr.io/@std/collections/1.1.3/deep_merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep_merge.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/collections/1.1.3/deep_merge.ts"],"names":[],"mappings":"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"}

package/esm/deps/jsr.io/@std/collections/1.1.3/deep_merge.js

@@ -0,0 +1,95 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { filterInPlace } from "./_utils.js";
+export function deepMerge(record, other, options) {
+    return deepMergeInternal(record, other, new Set(), options);
+}
+function deepMergeInternal(record, other, seen, options) {
+    const result = {};
+    const keys = new Set([
+        ...getKeys(record),
+        ...getKeys(other),
+    ]);
+    // Iterate through each key of other object and use correct merging strategy
+    for (const key of keys) {
+        // Skip to prevent Object.prototype.__proto__ accessor property calls on non-Deno platforms
+        if (key === "__proto__") {
+            continue;
+        }
+        const a = record[key];
+        if (!Object.hasOwn(other, key)) {
+            result[key] = a;
+            continue;
+        }
+        const b = other[key];
+        if (isNonNullObject(a) && isNonNullObject(b) && !seen.has(a) && !seen.has(b)) {
+            seen.add(a);
+            seen.add(b);
+            result[key] = mergeObjects(a, b, seen, options);
+            continue;
+        }
+        // Override value
+        result[key] = b;
+    }
+    return result;
+}
+function mergeObjects(left, right, seen, options = {
+    arrays: "merge",
+    sets: "merge",
+    maps: "merge",
+}) {
+    // Recursively merge mergeable objects
+    if (isMergeable(left) && isMergeable(right)) {
+        return deepMergeInternal(left, right, seen, options);
+    }
+    if (isIterable(left) && isIterable(right)) {
+        // Handle arrays
+        if ((Array.isArray(left)) && (Array.isArray(right))) {
+            if (options.arrays === "merge") {
+                return left.concat(right);
+            }
+            return right;
+        }
+        // Handle maps
+        if ((left instanceof Map) && (right instanceof Map)) {
+            if (options.maps === "merge") {
+                return new Map([
+                    ...left,
+                    ...right,
+                ]);
+            }
+            return right;
+        }
+        // Handle sets
+        if ((left instanceof Set) && (right instanceof Set)) {
+            if (options.sets === "merge") {
+                return new Set([
+                    ...left,
+                    ...right,
+                ]);
+            }
+            return right;
+        }
+    }
+    return right;
+}
+/**
+ * Test whether a value is mergeable or not
+ * Builtins that look like objects, null and user defined classes
+ * are not considered mergeable (it means that reference will be copied)
+ */
+function isMergeable(value) {
+    return Object.getPrototypeOf(value) === Object.prototype;
+}
+function isIterable(value) {
+    return typeof value[Symbol.iterator] === "function";
+}
+function isNonNullObject(value) {
+    return value !== null && typeof value === "object";
+}
+function getKeys(record) {
+    const result = Object.getOwnPropertySymbols(record);
+    filterInPlace(result, (key) => Object.prototype.propertyIsEnumerable.call(record, key));
+    result.push(...Object.keys(record));
+    return result;
+}

package/esm/deps/jsr.io/@std/front-matter/1.0.9/_formats.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Supported format for front matter. `"unknown"` is used when auto format
+ * detection logic fails.
+ */
+export type Format = "yaml" | "toml" | "json";
+export declare const EXTRACT_YAML_REGEXP: RegExp;
+export declare const EXTRACT_TOML_REGEXP: RegExp;
+export declare const EXTRACT_JSON_REGEXP: RegExp;
+export declare const RECOGNIZE_REGEXP_MAP: Map<string, RegExp>;
+export declare const EXTRACT_REGEXP_MAP: Map<string, RegExp>;
+//# sourceMappingURL=_formats.d.ts.map

package/esm/deps/jsr.io/@std/front-matter/1.0.9/_formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_formats.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/front-matter/1.0.9/_formats.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAgC9C,eAAO,MAAM,mBAAmB,QAG/B,CAAC;AACF,eAAO,MAAM,mBAAmB,QAG/B,CAAC;AACF,eAAO,MAAM,mBAAmB,QAG/B,CAAC;AAEF,eAAO,MAAM,oBAAoB,qBAI/B,CAAC;AAEH,eAAO,MAAM,kBAAkB,qBAI7B,CAAC"}

package/esm/deps/jsr.io/@std/front-matter/1.0.9/_formats.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+const BOM = "\\ufeff?";
+const YAML_HEADER = `${BOM}(?:---yaml|= yaml =|---)`;
+const YAML_FOOTER = `(?:= yaml =|---)`;
+const TOML_HEADER = `${BOM}(?:---toml|\\+\\+\\+|= toml =)`;
+const TOML_FOOTER = `(?:---|\\+\\+\\+|= toml =)`;
+const JSON_HEADER = `${BOM}(?:---json|= json =)`;
+const JSON_FOOTER = `(?:---|= json =)`;
+const WHITESPACES = "\\s*";
+const NEWLINE = "\\r?\\n";
+const FRONT_MATTER = "(?<frontMatter>.+?)";
+const BODY = "(?:\\r?\\n(?<body>.+))?";
+const RECOGNIZE_YAML_REGEXP = new RegExp(`^${YAML_HEADER}${WHITESPACES}${NEWLINE}`, "i");
+const RECOGNIZE_TOML_REGEXP = new RegExp(`^${TOML_HEADER}${WHITESPACES}${NEWLINE}`, "i");
+const RECOGNIZE_JSON_REGEXP = new RegExp(`^${JSON_HEADER}${WHITESPACES}${NEWLINE}`, "i");
+export const EXTRACT_YAML_REGEXP = new RegExp(`^${YAML_HEADER}${WHITESPACES}${NEWLINE}${WHITESPACES}(?:${FRONT_MATTER}${WHITESPACES}${NEWLINE})?${YAML_FOOTER}${WHITESPACES}${BODY}$`, "is");
+export const EXTRACT_TOML_REGEXP = new RegExp(`^${TOML_HEADER}${WHITESPACES}${NEWLINE}${WHITESPACES}(?:${FRONT_MATTER}${WHITESPACES}${NEWLINE})?${TOML_FOOTER}${WHITESPACES}${BODY}$`, "is");
+export const EXTRACT_JSON_REGEXP = new RegExp(`^${JSON_HEADER}${WHITESPACES}${NEWLINE}${WHITESPACES}(?:${FRONT_MATTER}${WHITESPACES}${NEWLINE})?${JSON_FOOTER}${WHITESPACES}${BODY}$`, "is");
+export const RECOGNIZE_REGEXP_MAP = new Map([
+    ["yaml", RECOGNIZE_YAML_REGEXP],
+    ["toml", RECOGNIZE_TOML_REGEXP],
+    ["json", RECOGNIZE_JSON_REGEXP],
+]);
+export const EXTRACT_REGEXP_MAP = new Map([
+    ["yaml", EXTRACT_YAML_REGEXP],
+    ["toml", EXTRACT_TOML_REGEXP],
+    ["json", EXTRACT_JSON_REGEXP],
+]);

package/esm/deps/jsr.io/@std/front-matter/1.0.9/_shared.d.ts

@@ -0,0 +1,5 @@
+export declare function extractFrontMatter(input: string, extractRegExp: RegExp): {
+    frontMatter: string;
+    body: string;
+};
+//# sourceMappingURL=_shared.d.ts.map

package/esm/deps/jsr.io/@std/front-matter/1.0.9/_shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_shared.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/front-matter/1.0.9/_shared.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAKvC"}

package/esm/deps/jsr.io/@std/front-matter/1.0.9/_shared.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export function extractFrontMatter(input, extractRegExp) {
+    const groups = extractRegExp.exec(input)?.groups;
+    if (!groups)
+        throw new TypeError("Unexpected end of input");
+    const { frontMatter = "", body = "" } = groups;
+    return { frontMatter, body };
+}

package/esm/deps/jsr.io/@std/front-matter/1.0.9/any.d.ts

@@ -0,0 +1,32 @@
+import type { Extract } from "./types.js";
+export type { Extract };
+/**
+ * Extracts and parses {@link https://yaml.org | YAML}, {@link https://toml.io |
+ * TOML}, or {@link https://www.json.org/ | JSON} from the metadata of front
+ * matter content, depending on the format.
+ *
+ * @example Usage
+ * ```ts
+ * import { extract } from "@std/front-matter/any";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const output = `---json
+ * {
+ *   "title": "Three dashes marks the spot"
+ * }
+ * ---
+ * Hello, world!`;
+ * const result = extract(output);
+ * assertEquals(result, {
+ *   frontMatter: '{\n  "title": "Three dashes marks the spot"\n}',
+ *   body: "Hello, world!",
+ *   attrs: { title: "Three dashes marks the spot" }
+ * })
+ * ```
+ *
+ * @typeParam T The type of the parsed front matter.
+ * @param text The text to extract front matter from.
+ * @returns The extracted front matter and body content.
+ */
+export declare function extract<T>(text: string): Extract<T>;
+//# sourceMappingURL=any.d.ts.map

package/esm/deps/jsr.io/@std/front-matter/1.0.9/any.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"any.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/front-matter/1.0.9/any.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,YAAY,EAAE,OAAO,EAAE,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAanD"}