@feiyoug/skill-lab 0.0.1 → 0.0.2

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

@@ -0,0 +1,183 @@
+// 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 type { KindType, Type } from "./_type.js";
+import { binary } from "./_type/binary.js";
+import { bool } from "./_type/bool.js";
+import { float } from "./_type/float.js";
+import { int } from "./_type/int.js";
+import { map } from "./_type/map.js";
+import { merge } from "./_type/merge.js";
+import { nil } from "./_type/nil.js";
+import { omap } from "./_type/omap.js";
+import { pairs } from "./_type/pairs.js";
+import { regexp } from "./_type/regexp.js";
+import { seq } from "./_type/seq.js";
+import { set } from "./_type/set.js";
+import { str } from "./_type/str.js";
+import { timestamp } from "./_type/timestamp.js";
+import { undefinedType } from "./_type/undefined.js";
+
+/**
+ * Name of the schema to use.
+ *
+ * > [!NOTE]
+ * > It is recommended to use the schema that is most appropriate for your use
+ * > case. Doing so will avoid any unnecessary processing and benefit
+ * > performance.
+ *
+ * Options include:
+ * - `failsafe`: supports generic mappings, generic sequences and generic
+ * strings.
+ * - `json`: extends `failsafe` schema by also supporting nulls, booleans,
+ * integers and floats.
+ * - `core`: functionally the same as `json` schema.
+ * - `default`: extends `core` schema by also supporting binary, omap, pairs and
+ * set types.
+ * - `extended`: extends `default` schema by also supporting regular
+ * expressions and undefined values.
+ *
+ * See
+ * {@link https://yaml.org/spec/1.2.2/#chapter-10-recommended-schemas | YAML 1.2 spec}
+ * for more details on the `failsafe`, `json` and `core` schemas.
+ */
+export type SchemaType = "failsafe" | "json" | "core" | "default" | "extended";
+
+/**
+ * A type that can be implicitly resolved (i.e. without using a tag) when
+ * loading a YAML document.
+ */
+export type ImplicitType = Type<"scalar">;
+export type ExplicitType = Type<KindType>;
+
+export type TypeMap = Record<
+  KindType | "fallback",
+  Map<string, ExplicitType>
+>;
+
+function createTypeMap(
+  implicitTypes: ImplicitType[],
+  explicitTypes: ExplicitType[],
+): TypeMap {
+  const result: TypeMap = {
+    fallback: new Map(),
+    mapping: new Map(),
+    scalar: new Map(),
+    sequence: new Map(),
+  };
+  const fallbackMap = result.fallback;
+  for (const type of [...implicitTypes, ...explicitTypes]) {
+    const map = result[type.kind];
+    map.set(type.tag, type);
+    fallbackMap.set(type.tag, type);
+  }
+  return result;
+}
+
+export interface Schema {
+  implicitTypes: ImplicitType[];
+  explicitTypes: ExplicitType[];
+  typeMap: TypeMap;
+}
+
+function createSchema({ explicitTypes = [], implicitTypes = [], include }: {
+  implicitTypes?: ImplicitType[];
+  explicitTypes?: ExplicitType[];
+  include?: Schema;
+}): Schema {
+  if (include) {
+    implicitTypes.push(...include.implicitTypes);
+    explicitTypes.push(...include.explicitTypes);
+  }
+  const typeMap = createTypeMap(implicitTypes, explicitTypes);
+  return { implicitTypes, explicitTypes, typeMap };
+}
+
+/**
+ * Standard YAML's failsafe schema.
+ *
+ * @see {@link http://www.yaml.org/spec/1.2/spec.html#id2802346}
+ */
+const FAILSAFE_SCHEMA = createSchema({
+  explicitTypes: [str, seq, map],
+});
+
+/**
+ * Standard YAML's JSON schema.
+ *
+ * @see {@link http://www.yaml.org/spec/1.2/spec.html#id2803231}
+ */
+const JSON_SCHEMA = createSchema({
+  implicitTypes: [nil, bool, int, float],
+  include: FAILSAFE_SCHEMA,
+});
+
+/**
+ * Standard YAML's core schema.
+ *
+ * @see {@link http://www.yaml.org/spec/1.2/spec.html#id2804923}
+ */
+const CORE_SCHEMA = createSchema({
+  include: JSON_SCHEMA,
+});
+
+/**
+ * Default YAML schema. It is not described in the YAML specification.
+ */
+export const DEFAULT_SCHEMA = createSchema({
+  explicitTypes: [binary, omap, pairs, set],
+  implicitTypes: [timestamp, merge],
+  include: CORE_SCHEMA,
+});
+
+/***
+ * Extends JS-YAML default schema with additional JavaScript types
+ * It is not described in the YAML specification.
+ * Functions are no longer supported for security reasons.
+ *
+ * @example
+ * ```ts
+ * import { parse } from "@std/yaml";
+ *
+ * const data = parse(
+ *   `
+ *   regexp:
+ *     simple: !!js/regexp foobar
+ *     modifiers: !!js/regexp /foobar/mi
+ *   undefined: !!js/undefined ~
+ * `,
+ *   { schema: "extended" },
+ * );
+ * ```
+ */
+const EXTENDED_SCHEMA = createSchema({
+  explicitTypes: [regexp, undefinedType],
+  include: DEFAULT_SCHEMA,
+});
+
+export const SCHEMA_MAP = new Map<SchemaType, Schema>([
+  ["core", CORE_SCHEMA],
+  ["default", DEFAULT_SCHEMA],
+  ["failsafe", FAILSAFE_SCHEMA],
+  ["json", JSON_SCHEMA],
+  ["extended", EXTENDED_SCHEMA],
+]);
+
+export function getSchema(
+  schema: SchemaType = "default",
+  types?: ImplicitType[],
+): Schema {
+  const schemaObj = SCHEMA_MAP.get(schema)!;
+
+  if (!types) {
+    return schemaObj;
+  }
+
+  return createSchema({
+    implicitTypes: [...types, ...schemaObj.implicitTypes],
+    explicitTypes: [...schemaObj.explicitTypes],
+  });
+}

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

@@ -0,0 +1,127 @@
+// Ported from js-yaml v3.13.1:
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2018-2026 the Deno authors. MIT license.
+import type { Type } from "../_type.js";
+
+// [ 64, 65, 66 ] -> [ padding, CR, LF ]
+const BASE64_MAP =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+
+function resolveYamlBinary(data: string): boolean {
+  if (data === null) return false;
+
+  let code: number;
+  let bitlen = 0;
+  const max = data.length;
+  const map = BASE64_MAP;
+
+  // Convert one by one.
+  for (let idx = 0; idx < max; idx++) {
+    code = map.indexOf(data.charAt(idx));
+
+    // Skip CR/LF
+    if (code > 64) continue;
+
+    // Fail on illegal characters
+    if (code < 0) return false;
+
+    bitlen += 6;
+  }
+
+  // If there are any bits left, source was corrupted
+  return bitlen % 8 === 0;
+}
+
+function constructYamlBinary(data: string): Uint8Array {
+  // remove CR/LF & padding to simplify scan
+  const input = data.replace(/[\r\n=]/g, "");
+  const max = input.length;
+  const map = BASE64_MAP;
+
+  // Collect by 6*4 bits (3 bytes)
+
+  const result = [];
+  let bits = 0;
+  for (let idx = 0; idx < max; idx++) {
+    if (idx % 4 === 0 && idx) {
+      result.push((bits >> 16) & 0xff);
+      result.push((bits >> 8) & 0xff);
+      result.push(bits & 0xff);
+    }
+
+    bits = (bits << 6) | map.indexOf(input.charAt(idx));
+  }
+
+  // Dump tail
+
+  const tailbits = (max % 4) * 6;
+
+  if (tailbits === 0) {
+    result.push((bits >> 16) & 0xff);
+    result.push((bits >> 8) & 0xff);
+    result.push(bits & 0xff);
+  } else if (tailbits === 18) {
+    result.push((bits >> 10) & 0xff);
+    result.push((bits >> 2) & 0xff);
+  } else if (tailbits === 12) {
+    result.push((bits >> 4) & 0xff);
+  }
+
+  return new Uint8Array(result);
+}
+
+function representYamlBinary(object: Uint8Array): string {
+  const max = object.length;
+  const map = BASE64_MAP;
+
+  // Convert every three bytes to 4 ASCII characters.
+
+  let result = "";
+  let bits = 0;
+  for (let idx = 0; idx < max; idx++) {
+    if (idx % 3 === 0 && idx) {
+      result += map[(bits >> 18) & 0x3f];
+      result += map[(bits >> 12) & 0x3f];
+      result += map[(bits >> 6) & 0x3f];
+      result += map[bits & 0x3f];
+    }
+
+    bits = (bits << 8) + object[idx]!;
+  }
+
+  // Dump tail
+
+  const tail = max % 3;
+
+  if (tail === 0) {
+    result += map[(bits >> 18) & 0x3f];
+    result += map[(bits >> 12) & 0x3f];
+    result += map[(bits >> 6) & 0x3f];
+    result += map[bits & 0x3f];
+  } else if (tail === 2) {
+    result += map[(bits >> 10) & 0x3f];
+    result += map[(bits >> 4) & 0x3f];
+    result += map[(bits << 2) & 0x3f];
+    result += map[64];
+  } else if (tail === 1) {
+    result += map[(bits >> 2) & 0x3f];
+    result += map[(bits << 4) & 0x3f];
+    result += map[64];
+    result += map[64];
+  }
+
+  return result;
+}
+function isBinary(obj: unknown): obj is Uint8Array {
+  return obj instanceof Uint8Array;
+}
+
+export const binary: Type<"scalar", Uint8Array> = {
+  tag: "tag:yaml.org,2002:binary",
+  construct: constructYamlBinary,
+  kind: "scalar",
+  predicate: isBinary,
+  represent: representYamlBinary,
+  resolve: resolveYamlBinary,
+};

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

@@ -0,0 +1,37 @@
+// 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_TRUE_BOOLEANS = ["true", "True", "TRUE"];
+const YAML_FALSE_BOOLEANS = ["false", "False", "FALSE"];
+const YAML_BOOLEANS = [...YAML_TRUE_BOOLEANS, ...YAML_FALSE_BOOLEANS];
+
+export const bool: Type<"scalar", boolean> = {
+  tag: "tag:yaml.org,2002:bool",
+  kind: "scalar",
+  defaultStyle: "lowercase",
+  predicate: (value: unknown): value is boolean =>
+    typeof value === "boolean" || value instanceof Boolean,
+  construct: (data: string): boolean => YAML_TRUE_BOOLEANS.includes(data),
+  resolve: (data: string): boolean => YAML_BOOLEANS.includes(data),
+  represent: {
+    // deno-lint-ignore ban-types
+    lowercase: (object: boolean | Boolean): string => {
+      const value = object instanceof Boolean ? object.valueOf() : object;
+      return value ? "true" : "false";
+    },
+    // deno-lint-ignore ban-types
+    uppercase: (object: boolean | Boolean): string => {
+      const value = object instanceof Boolean ? object.valueOf() : object;
+      return value ? "TRUE" : "FALSE";
+    },
+    // deno-lint-ignore ban-types
+    camelcase: (object: boolean | Boolean): string => {
+      const value = object instanceof Boolean ? object.valueOf() : object;
+      return value ? "True" : "False";
+    },
+  },
+};

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

@@ -0,0 +1,112 @@
+// 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 { StyleVariant, Type } from "../_type.js";
+import { isNegativeZero } from "../_utils.js";
+
+const YAML_FLOAT_PATTERN = new RegExp(
+  // 2.5e4, 2.5 and integers
+  "^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?" +
+    // .2e4, .2
+    // special case, seems not from spec
+    "|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?" +
+    // .inf
+    "|[-+]?\\.(?:inf|Inf|INF)" +
+    // .nan
+    "|\\.(?:nan|NaN|NAN))$",
+);
+
+function resolveYamlFloat(data: string): boolean {
+  if (
+    !YAML_FLOAT_PATTERN.test(data) ||
+    // Quick hack to not allow integers end with `_`
+    // Probably should update regexp & check speed
+    data[data.length - 1] === "_"
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function constructYamlFloat(data: string): number {
+  let value = data.replace(/_/g, "").toLowerCase();
+  const sign = value[0] === "-" ? -1 : 1;
+
+  if (value[0] && "+-".includes(value[0])) {
+    value = value.slice(1);
+  }
+
+  if (value === ".inf") {
+    return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  }
+  if (value === ".nan") {
+    return NaN;
+  }
+  return sign * parseFloat(value);
+}
+
+const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+
+function representYamlFloat(
+  // deno-lint-ignore ban-types
+  object: number | Number,
+  style?: StyleVariant,
+): string {
+  const value = object instanceof Number ? object.valueOf() : object;
+  if (isNaN(value)) {
+    switch (style) {
+      case "lowercase":
+        return ".nan";
+      case "uppercase":
+        return ".NAN";
+      case "camelcase":
+        return ".NaN";
+    }
+  } else if (Number.POSITIVE_INFINITY === value) {
+    switch (style) {
+      case "lowercase":
+        return ".inf";
+      case "uppercase":
+        return ".INF";
+      case "camelcase":
+        return ".Inf";
+    }
+  } else if (Number.NEGATIVE_INFINITY === value) {
+    switch (style) {
+      case "lowercase":
+        return "-.inf";
+      case "uppercase":
+        return "-.INF";
+      case "camelcase":
+        return "-.Inf";
+    }
+  } else if (isNegativeZero(value)) {
+    return "-0.0";
+  }
+
+  const res = value.toString(10);
+
+  // JS stringifier can build scientific format without dots: 5e-100,
+  // while YAML requires dot: 5.e-100. Fix it with simple hack
+
+  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+}
+
+function isFloat(object: unknown): object is number {
+  if (object instanceof Number) object = object.valueOf();
+  return typeof object === "number" &&
+    (object % 1 !== 0 || isNegativeZero(object));
+}
+
+export const float: Type<"scalar", number> = {
+  tag: "tag:yaml.org,2002:float",
+  construct: constructYamlFloat,
+  defaultStyle: "lowercase",
+  kind: "scalar",
+  predicate: isFloat,
+  represent: representYamlFloat,
+  resolve: resolveYamlFloat,
+};

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

@@ -0,0 +1,174 @@
+// 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 { isNegativeZero } from "../_utils.js";
+
+function isCharCodeInRange(c: number, lower: number, upper: number): boolean {
+  return lower <= c && c <= upper;
+}
+
+function isHexCode(c: number): boolean {
+  return (
+    isCharCodeInRange(c, 0x30, 0x39) || // 0-9
+    isCharCodeInRange(c, 0x41, 0x46) || // A-F
+    isCharCodeInRange(c, 0x61, 0x66) // a-f
+  );
+}
+
+function isOctCode(c: number): boolean {
+  return isCharCodeInRange(c, 0x30, 0x37); // 0-7
+}
+
+function isDecCode(c: number): boolean {
+  return isCharCodeInRange(c, 0x30, 0x39); // 0-9
+}
+
+function resolveYamlInteger(data: string): boolean {
+  const max = data.length;
+  let index = 0;
+  let hasDigits = false;
+
+  if (!max) return false;
+
+  let ch = data[index];
+
+  // sign
+  if (ch === "-" || ch === "+") {
+    ch = data[++index];
+  }
+
+  if (ch === "0") {
+    // 0
+    if (index + 1 === max) return true;
+    ch = data[++index];
+
+    // base 2, base 8, base 16
+
+    if (ch === "b") {
+      // base 2
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (ch !== "0" && ch !== "1") return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+
+    if (ch === "x") {
+      // base 16
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (!isHexCode(data.charCodeAt(index))) return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+
+    // base 8
+    for (; index < max; index++) {
+      ch = data[index];
+      if (ch === "_") continue;
+      if (!isOctCode(data.charCodeAt(index))) return false;
+      hasDigits = true;
+    }
+    return hasDigits && ch !== "_";
+  }
+
+  // base 10 (except 0) or base 60
+
+  // value should not start with `_`;
+  if (ch === "_") return false;
+
+  for (; index < max; index++) {
+    ch = data[index];
+    if (ch === "_") continue;
+    if (!isDecCode(data.charCodeAt(index))) {
+      return false;
+    }
+    hasDigits = true;
+  }
+
+  // Should have digits and should not end with `_`
+  if (!hasDigits || ch === "_") return false;
+
+  // base60 almost not used, no needs to optimize
+  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+
+function constructYamlInteger(data: string): number {
+  let value = data;
+
+  if (value.includes("_")) {
+    value = value.replace(/_/g, "");
+  }
+
+  let sign = 1;
+  let ch = value[0];
+  if (ch === "-" || ch === "+") {
+    if (ch === "-") sign = -1;
+    value = value.slice(1);
+    ch = value[0];
+  }
+
+  if (value === "0") return 0;
+
+  if (ch === "0") {
+    if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+    if (value[1] === "x") return sign * parseInt(value, 16);
+    return sign * parseInt(value, 8);
+  }
+
+  return sign * parseInt(value, 10);
+}
+
+function isInteger(object: unknown): object is number {
+  if (object instanceof Number) object = object.valueOf();
+  return typeof object === "number" && object % 1 === 0 &&
+    !isNegativeZero(object);
+}
+
+export const int: Type<"scalar", number> = {
+  tag: "tag:yaml.org,2002:int",
+  construct: constructYamlInteger,
+  defaultStyle: "decimal",
+  kind: "scalar",
+  predicate: isInteger,
+  represent: {
+    // deno-lint-ignore ban-types
+    binary(object: number | Number): string {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value >= 0
+        ? `0b${value.toString(2)}`
+        : `-0b${value.toString(2).slice(1)}`;
+    },
+    // deno-lint-ignore ban-types
+    octal(object: number | Number): string {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value >= 0
+        ? `0${value.toString(8)}`
+        : `-0${value.toString(8).slice(1)}`;
+    },
+    // deno-lint-ignore ban-types
+    decimal(object: number | Number): string {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value.toString(10);
+    },
+    // deno-lint-ignore ban-types
+    hexadecimal(object: number | Number): string {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value >= 0
+        ? `0x${value.toString(16).toUpperCase()}`
+        : `-0x${value.toString(16).toUpperCase().slice(1)}`;
+    },
+  },
+  resolve: resolveYamlInteger,
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/map.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 map: Type<"mapping", unknown> = {
+  tag: "tag:yaml.org,2002:map",
+  resolve() {
+    return true;
+  },
+  construct(data) {
+    return data !== null ? data : {};
+  },
+  kind: "mapping",
+};

package/src/deps/jsr.io/@std/yaml/1.0.11/_type/merge.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 merge: Type<"scalar", unknown> = {
+  tag: "tag:yaml.org,2002:merge",
+  kind: "scalar",
+  resolve: (data: unknown): boolean => data === "<<" || data === null,
+  construct: (data: unknown): unknown => data,
+};

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

@@ -0,0 +1,27 @@
+// 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 nil: Type<"scalar", null> = {
+  tag: "tag:yaml.org,2002:null",
+  kind: "scalar",
+  defaultStyle: "lowercase",
+  predicate: (object: unknown): object is null => object === null,
+  construct: () => null,
+  resolve: (data: string): boolean => {
+    return (
+      data === "~" ||
+      data === "null" ||
+      data === "Null" ||
+      data === "NULL"
+    );
+  },
+  represent: {
+    lowercase: (): string => "null",
+    uppercase: (): string => "NULL",
+    camelcase: (): string => "Null",
+  },
+};