@feiyoug/skill-lab 0.0.1 → 0.0.2

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/omap.ts

@@ -0,0 +1,30 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+import { isPlainObject } from "../_utils.js";
+
+function resolveYamlOmap(data: Record<string, unknown>[]): boolean {
+  const objectKeys = new Set();
+  for (const object of data) {
+    if (!isPlainObject(object)) return false;
+    const keys = Object.keys(object);
+    if (keys.length !== 1) return false;
+    for (const key of keys) {
+      if (objectKeys.has(key)) return false;
+      objectKeys.add(key);
+    }
+  }
+  return true;
+}
+
+export const omap: Type<"sequence", Record<PropertyKey, unknown>[]> = {
+  tag: "tag:yaml.org,2002:omap",
+  kind: "sequence",
+  resolve: resolveYamlOmap,
+  construct(data) {
+    return data;
+  },
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/pairs.ts

@@ -0,0 +1,22 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+import { isPlainObject } from "../_utils.js";
+
+function resolveYamlPairs(data: unknown[][]): boolean {
+  if (data === null) return true;
+  return data.every((it) => isPlainObject(it) && Object.keys(it).length === 1);
+}
+
+export const pairs: Type<"sequence"> = {
+  tag: "tag:yaml.org,2002:pairs",
+  construct(data: Record<string, unknown>[] | null): [string, unknown][] {
+    // Converts an array of objects into an array of key-value pairs.
+    return data?.flatMap(Object.entries) ?? [];
+  },
+  kind: "sequence",
+  resolve: resolveYamlPairs,
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/regexp.ts

@@ -0,0 +1,33 @@
+// Ported and adapted from js-yaml-js-types v1.0.0:
+// https://github.com/nodeca/js-yaml-js-types/tree/ac537e7bbdd3c2cbbd9882ca3919c520c2dc022b
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+
+const REGEXP = /^\/(?<regexp>[\s\S]+)\/(?<modifiers>[gismuy]*)$/;
+
+export const regexp: Type<"scalar", RegExp> = {
+  tag: "tag:yaml.org,2002:js/regexp",
+  kind: "scalar",
+  resolve(data: string | null): boolean {
+    if (data === null || !data.length) return false;
+
+    if (data.charAt(0) === "/") {
+      // Ensure regex is properly terminated
+      const groups = data.match(REGEXP)?.groups;
+      if (!groups) return false;
+      // Check no duplicate modifiers
+      const modifiers = groups.modifiers ?? "";
+      if (new Set(modifiers).size < modifiers.length) return false;
+    }
+
+    return true;
+  },
+  construct(data: string): RegExp {
+    const { regexp = data, modifiers = "" } = data.match(REGEXP)?.groups ?? {};
+    return new RegExp(regexp, modifiers);
+  },
+  predicate: (object: unknown): object is RegExp => object instanceof RegExp,
+  represent: (object: RegExp): string => object.toString(),
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/seq.ts

@@ -0,0 +1,13 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+
+export const seq: Type<"sequence", unknown[]> = {
+  tag: "tag:yaml.org,2002:seq",
+  kind: "sequence",
+  resolve: (): boolean => true,
+  construct: (data: unknown[] | null): unknown[] => data !== null ? data : [],
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/set.ts

@@ -0,0 +1,17 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+
+export const set: Type<"mapping", Record<PropertyKey, unknown>> = {
+  tag: "tag:yaml.org,2002:set",
+  kind: "mapping",
+  construct: (data: Record<string, unknown>): Record<string, unknown> =>
+    data !== null ? data : {},
+  resolve: (data: Record<string, unknown>): boolean => {
+    if (data === null) return true;
+    return Object.values(data).every((it) => it === null);
+  },
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/str.ts

@@ -0,0 +1,12 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+
+export const str: Type<"scalar", string> = {
+  tag: "tag:yaml.org,2002:str",
+  kind: "scalar",
+  resolve: (): boolean => true,
+  construct: (data: string | null): string => data !== null ? data : "",
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/timestamp.ts

@@ -0,0 +1,101 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+
+const YAML_DATE_REGEXP = new RegExp(
+  "^([0-9][0-9][0-9][0-9])" + // [1] year
+    "-([0-9][0-9])" + // [2] month
+    "-([0-9][0-9])$", // [3] day
+);
+
+const YAML_TIMESTAMP_REGEXP = new RegExp(
+  "^([0-9][0-9][0-9][0-9])" + // [1] year
+    "-([0-9][0-9]?)" + // [2] month
+    "-([0-9][0-9]?)" + // [3] day
+    "(?:[Tt]|[ \\t]+)" + // ...
+    "([0-9][0-9]?)" + // [4] hour
+    ":([0-9][0-9])" + // [5] minute
+    ":([0-9][0-9])" + // [6] second
+    "(?:\\.([0-9]*))?" + // [7] fraction
+    "(?:[ \\t]*(Z|([-+])([0-9][0-9]?)" + // [8] tz [9] tz_sign [10] tz_hour
+    "(?::([0-9][0-9]))?))?$", // [11] tz_minute
+);
+
+function resolveYamlTimestamp(data: string): boolean {
+  if (data === null) return false;
+  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+  return false;
+}
+
+function constructYamlTimestamp(data: string): Date {
+  let match = YAML_DATE_REGEXP.exec(data);
+  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+
+  if (match === null) {
+    throw new Error("Cannot construct YAML timestamp: date resolve error");
+  }
+
+  // match: [1] year [2] month [3] day
+
+  const year = +match[1]!;
+  const month = +match[2]! - 1; // JS month starts with 0
+  const day = +match[3]!;
+
+  if (!match[4]) {
+    // no hour
+    return new Date(Date.UTC(year, month, day));
+  }
+
+  // match: [4] hour [5] minute [6] second [7] fraction
+
+  const hour = +match[4];
+  const minute = +match[5]!;
+  const second = +match[6]!;
+
+  let fraction = 0;
+  if (match[7]) {
+    let partFraction = match[7].slice(0, 3);
+    while (partFraction.length < 3) {
+      // milli-seconds
+      partFraction += "0";
+    }
+    fraction = +partFraction;
+  }
+
+  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
+
+  let delta = null;
+  if (match[9] && match[10]) {
+    const tzHour = +match[10];
+    const tzMinute = +(match[11] || 0);
+    delta = (tzHour * 60 + tzMinute) * 60000; // delta in milli-seconds
+    if (match[9] === "-") delta = -delta;
+  }
+
+  const date = new Date(
+    Date.UTC(year, month, day, hour, minute, second, fraction),
+  );
+
+  if (delta) date.setTime(date.getTime() - delta);
+
+  return date;
+}
+
+function representYamlTimestamp(date: Date): string {
+  return date.toISOString();
+}
+
+export const timestamp: Type<"scalar", Date> = {
+  tag: "tag:yaml.org,2002:timestamp",
+  construct: constructYamlTimestamp,
+  predicate(object): object is Date {
+    return object instanceof Date;
+  },
+  kind: "scalar",
+  represent: representYamlTimestamp,
+  resolve: resolveYamlTimestamp,
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/undefined.ts

@@ -0,0 +1,23 @@
+// Ported and adapted from js-yaml-js-types v1.0.0:
+// https://github.com/nodeca/js-yaml-js-types/tree/ac537e7bbdd3c2cbbd9882ca3919c520c2dc022b
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import type { Type } from "../_type.js";
+
+export const undefinedType: Type<"scalar", undefined> = {
+  tag: "tag:yaml.org,2002:js/undefined",
+  kind: "scalar",
+  resolve() {
+    return true;
+  },
+  construct() {
+    return undefined;
+  },
+  predicate(object) {
+    return typeof object === "undefined";
+  },
+  represent() {
+    return "";
+  },
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type.ts

@@ -0,0 +1,49 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * The kind of YAML node.
+ */
+export type KindType = "sequence" | "scalar" | "mapping";
+/**
+ * The style variation for `styles` option of {@linkcode stringify}
+ */
+export type StyleVariant =
+  | "lowercase"
+  | "uppercase"
+  | "camelcase"
+  | "decimal"
+  | "binary"
+  | "octal"
+  | "hexadecimal";
+
+/**
+ * Function to convert data to a string for YAML serialization.
+ */
+export type RepresentFn<D> = (data: D, style?: StyleVariant) => string;
+
+/**
+ * A type definition for a YAML node.
+ */
+// deno-lint-ignore no-explicit-any
+export interface Type<K extends KindType, D = any> {
+  /** Tag to identify the type */
+  tag: string;
+  /** Kind of type */
+  kind: K;
+  /** Cast the type. Used to stringify */
+  predicate?: (data: unknown) => data is D;
+  /** Function to represent data. Used to stringify */
+  represent?: RepresentFn<D> | Record<string, RepresentFn<D>>;
+  /** Default style for the type. Used to stringify */
+  defaultStyle?: StyleVariant;
+  /** Function to test whether data can be resolved by this type. Used to parse */
+  // deno-lint-ignore no-explicit-any
+  resolve: (data: any) => boolean;
+  /** Function to construct data from string. Used to parse */
+  // deno-lint-ignore no-explicit-any
+  construct: (data: any) => D;
+}

package/src/deps/jsr.io/@std/yaml/1.0.11/_utils.ts

@@ -0,0 +1,16 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+export function isNegativeZero(i: number): boolean {
+  return i === 0 && Number.NEGATIVE_INFINITY === 1 / i;
+}
+
+export function isPlainObject(object: unknown): object is object {
+  return Object.prototype.toString.call(object) === "[object Object]";
+}

package/src/deps/jsr.io/@std/yaml/1.0.11/mod.ts

@@ -0,0 +1,54 @@
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://yaml.org/ | YAML} encoded data.
+ *
+ * Ported from
+ * {@link https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da | js-yaml v3.13.1}.
+ *
+ * Use {@linkcode parseAll} for parsing multiple documents in a single YAML
+ * string.
+ *
+ * This package generally supports
+ * {@link https://yaml.org/spec/1.2.2/ | YAML 1.2.x} (latest) and some
+ * {@link https://yaml.org/spec/1.1/current.html | YAML 1.1} features that are
+ * commonly used in the wild.
+ *
+ * Supported YAML 1.1 features include:
+ * - {@link https://yaml.org/type/merge.html | Merge} type (`<<` symbol)
+ *
+ * Unsupported YAML 1.1 features include:
+ * - Yes, No, On, Off literals for bool type
+ * - Sexagesimal numbers (e.g. `3:25:45`)
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/yaml";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = parse(`
+ * foo: bar
+ * baz:
+ *   - qux
+ *   - quux
+ * `);
+ * assertEquals(data, { foo: "bar", baz: [ "qux", "quux" ] });
+ *
+ * const yaml = stringify({ foo: "bar", baz: ["qux", "quux"] });
+ * assertEquals(yaml, `foo: bar
+ * baz:
+ *   - qux
+ *   - quux
+ * `);
+ * ```
+ *
+ * ## Limitations
+ * - `binary` type is currently not stable.
+ *
+ * @module
+ */
+
+export * from "./parse.js";
+export * from "./stringify.js";

package/src/deps/jsr.io/@std/yaml/1.0.11/parse.ts

@@ -0,0 +1,128 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { isEOL } from "./_chars.js";
+import { LoaderState } from "./_loader_state.js";
+import { SCHEMA_MAP, type SchemaType } from "./_schema.js";
+
+export type { SchemaType };
+
+/** Options for {@linkcode parse}. */
+export interface ParseOptions {
+  /**
+   * Name of the schema to use.
+   *
+   * @default {"default"}
+   */
+  schema?: SchemaType;
+  /**
+   * If `true`, duplicate keys will overwrite previous values. Otherwise,
+   * duplicate keys will throw a {@linkcode SyntaxError}.
+   *
+   * @default {false}
+   */
+  allowDuplicateKeys?: boolean;
+  /**
+   * If defined, a function to call on warning messages taking an
+   * {@linkcode Error} as its only argument.
+   */
+  onWarning?(error: Error): void;
+}
+
+function sanitizeInput(input: string) {
+  input = String(input);
+
+  if (input.length > 0) {
+    // Add trailing `\n` if not exists
+    if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
+
+    // Strip BOM
+    if (input.charCodeAt(0) === 0xfeff) input = input.slice(1);
+  }
+
+  // Use 0 as string terminator. That significantly simplifies bounds check.
+  input += "\0";
+
+  return input;
+}
+
+/**
+ * Parse and return a YAML string as a parsed YAML document object.
+ *
+ * Note: This does not support functions. Untrusted data is safe to parse.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/yaml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = parse(`
+ * id: 1
+ * name: Alice
+ * `);
+ *
+ * assertEquals(data, { id: 1, name: "Alice" });
+ * ```
+ *
+ * @throws {SyntaxError} Throws error on invalid YAML.
+ * @param content YAML string to parse.
+ * @param options Parsing options.
+ * @returns Parsed document.
+ */
+export function parse(
+  content: string,
+  options: ParseOptions = {},
+): unknown {
+  content = sanitizeInput(content);
+  const state = new LoaderState(content, {
+    ...options,
+    schema: SCHEMA_MAP.get(options.schema!)!,
+  });
+  const documentGenerator = state.readDocuments();
+  const document = documentGenerator.next().value;
+  if (!documentGenerator.next().done) {
+    throw new SyntaxError(
+      "Found more than 1 document in the stream: expected a single document",
+    );
+  }
+  return document ?? null;
+}
+
+/**
+ * Same as {@linkcode parse}, but understands multi-document YAML sources, and
+ * returns multiple parsed YAML document objects.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseAll } from "@std/yaml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = parseAll(`
+ * ---
+ * id: 1
+ * name: Alice
+ * ---
+ * id: 2
+ * name: Bob
+ * ---
+ * id: 3
+ * name: Eve
+ * `);
+ * assertEquals(data, [ { id: 1, name: "Alice" }, { id: 2, name: "Bob" }, { id: 3, name: "Eve" }]);
+ * ```
+ *
+ * @param content YAML string to parse.
+ * @param options Parsing options.
+ * @returns Array of parsed documents.
+ */
+export function parseAll(content: string, options: ParseOptions = {}): unknown {
+  content = sanitizeInput(content);
+  const state = new LoaderState(content, {
+    ...options,
+    schema: SCHEMA_MAP.get(options.schema!)!,
+  });
+  return [...state.readDocuments()];
+}

package/src/deps/jsr.io/@std/yaml/1.0.11/stringify.ts

@@ -0,0 +1,118 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+
+import { DumperState } from "./_dumper_state.js";
+import { SCHEMA_MAP, type SchemaType } from "./_schema.js";
+import type { StyleVariant } from "./_type.js";
+
+export type { SchemaType, StyleVariant };
+
+/** Options for {@linkcode stringify}. */
+export type StringifyOptions = {
+  /**
+   * Indentation width to use (in spaces).
+   *
+   * @default {2}
+   */
+  indent?: number;
+  /**
+   * When true, adds an indentation level to array elements.
+   *
+   * @default {true}
+   */
+  arrayIndent?: boolean;
+  /**
+   * Do not throw on invalid types (like function in the safe schema) and skip
+   * pairs and single values with such types.
+   *
+   * @default {false}
+   */
+  skipInvalid?: boolean;
+  /**
+   * Specifies level of nesting, when to switch from block to flow style for
+   * collections. `-1` means block style everywhere.
+   *
+   * @default {-1}
+   */
+  flowLevel?: number;
+  /** Each tag may have own set of styles.	- "tag" => "style" map. */
+  styles?: Record<string, StyleVariant>;
+  /**
+   * Name of the schema to use.
+   *
+   * @default {"default"}
+   */
+  schema?: SchemaType;
+  /**
+   * If true, sort keys when dumping YAML in ascending, ASCII character order.
+   * If a function, use the function to sort the keys.
+   * If a function is specified, the function must return a negative value
+   * if first argument is less than second argument, zero if they're equal
+   * and a positive value otherwise.
+   *
+   * @default {false}
+   */
+  sortKeys?: boolean | ((a: string, b: string) => number);
+  /**
+   * Set max line width.
+   *
+   * @default {80}
+   */
+  lineWidth?: number;
+  /**
+   * If false, don't convert duplicate objects into references.
+   *
+   * @default {true}
+   */
+  useAnchors?: boolean;
+  /**
+   * If false don't try to be compatible with older yaml versions.
+   * Currently: don't quote "yes", "no" and so on,
+   * as required for YAML 1.1.
+   *
+   * @default {true}
+   */
+  compatMode?: boolean;
+  /**
+   * If true flow sequences will be condensed, omitting the
+   * space between `key: value` or `a, b`. Eg. `'[a,b]'` or `{a:{b:c}}`.
+   * Can be useful when using yaml for pretty URL query params
+   * as spaces are %-encoded.
+   *
+   * @default {false}
+   */
+  condenseFlow?: boolean;
+};
+
+/**
+ * Converts a JavaScript object or value to a YAML document string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/yaml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = { id: 1, name: "Alice" };
+ * const yaml = stringify(data);
+ *
+ * assertEquals(yaml, "id: 1\nname: Alice\n");
+ * ```
+ *
+ * @throws {TypeError} If `data` contains invalid types.
+ * @param data The data to serialize.
+ * @param options The options for serialization.
+ * @returns A YAML string.
+ */
+export function stringify(
+  data: unknown,
+  options: StringifyOptions = {},
+): string {
+  const state = new DumperState({
+    ...options,
+    schema: SCHEMA_MAP.get(options.schema!)!,
+  });
+  return state.stringify(data);
+}