diff options
Diffstat (limited to 'MistyCore/node_modules/yaml/dist/schema')
42 files changed, 1376 insertions, 0 deletions
diff --git a/MistyCore/node_modules/yaml/dist/schema/Schema.d.ts b/MistyCore/node_modules/yaml/dist/schema/Schema.d.ts new file mode 100644 index 0000000..0d53d5b --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/Schema.d.ts @@ -0,0 +1,18 @@ +import { MAP, SCALAR, SEQ } from '../nodes/Node.js'; +import type { Pair } from '../nodes/Pair.js'; +import type { SchemaOptions, ToStringOptions } from '../options.js'; +import type { CollectionTag, ScalarTag } from './types.js'; +export declare class Schema { + compat: Array<CollectionTag | ScalarTag> | null; + knownTags: Record<string, CollectionTag | ScalarTag>; + merge: boolean; + name: string; + sortMapEntries: ((a: Pair, b: Pair) => number) | null; + tags: Array<CollectionTag | ScalarTag>; + toStringOptions: Readonly<ToStringOptions> | null; + readonly [MAP]: CollectionTag; + readonly [SCALAR]: ScalarTag; + readonly [SEQ]: CollectionTag; + constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }: SchemaOptions); + clone(): Schema; +} diff --git a/MistyCore/node_modules/yaml/dist/schema/Schema.js b/MistyCore/node_modules/yaml/dist/schema/Schema.js new file mode 100644 index 0000000..f31b1a9 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/Schema.js @@ -0,0 +1,40 @@ +'use strict'; + +var Node = require('../nodes/Node.js'); +var map = require('./common/map.js'); +var seq = require('./common/seq.js'); +var string = require('./common/string.js'); +var tags = require('./tags.js'); + +const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0; +class Schema { + constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) { + this.compat = Array.isArray(compat) + ? tags.getTags(compat, 'compat') + : compat + ? tags.getTags(null, compat) + : null; + this.merge = !!merge; + this.name = (typeof schema === 'string' && schema) || 'core'; + this.knownTags = resolveKnownTags ? tags.coreKnownTags : {}; + this.tags = tags.getTags(customTags, this.name); + this.toStringOptions = toStringDefaults ?? null; + Object.defineProperty(this, Node.MAP, { value: map.map }); + Object.defineProperty(this, Node.SCALAR, { value: string.string }); + Object.defineProperty(this, Node.SEQ, { value: seq.seq }); + // Used by createMap() + this.sortMapEntries = + typeof sortMapEntries === 'function' + ? sortMapEntries + : sortMapEntries === true + ? sortMapEntriesByKey + : null; + } + clone() { + const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this)); + copy.tags = this.tags.slice(); + return copy; + } +} + +exports.Schema = Schema; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/map.d.ts b/MistyCore/node_modules/yaml/dist/schema/common/map.d.ts new file mode 100644 index 0000000..9b300f8 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/map.d.ts @@ -0,0 +1,2 @@ +import type { CollectionTag } from '../types.js'; +export declare const map: CollectionTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/map.js b/MistyCore/node_modules/yaml/dist/schema/common/map.js new file mode 100644 index 0000000..46dab3c --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/map.js @@ -0,0 +1,44 @@ +'use strict'; + +var Node = require('../../nodes/Node.js'); +var Pair = require('../../nodes/Pair.js'); +var YAMLMap = require('../../nodes/YAMLMap.js'); + +function createMap(schema, obj, ctx) { + const { keepUndefined, replacer } = ctx; + const map = new YAMLMap.YAMLMap(schema); + const add = (key, value) => { + if (typeof replacer === 'function') + value = replacer.call(obj, key, value); + else if (Array.isArray(replacer) && !replacer.includes(key)) + return; + if (value !== undefined || keepUndefined) + map.items.push(Pair.createPair(key, value, ctx)); + }; + if (obj instanceof Map) { + for (const [key, value] of obj) + add(key, value); + } + else if (obj && typeof obj === 'object') { + for (const key of Object.keys(obj)) + add(key, obj[key]); + } + if (typeof schema.sortMapEntries === 'function') { + map.items.sort(schema.sortMapEntries); + } + return map; +} +const map = { + collection: 'map', + createNode: createMap, + default: true, + nodeClass: YAMLMap.YAMLMap, + tag: 'tag:yaml.org,2002:map', + resolve(map, onError) { + if (!Node.isMap(map)) + onError('Expected a mapping for this tag'); + return map; + } +}; + +exports.map = map; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/null.d.ts b/MistyCore/node_modules/yaml/dist/schema/common/null.d.ts new file mode 100644 index 0000000..66abea5 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/null.d.ts @@ -0,0 +1,4 @@ +import type { ScalarTag } from '../types.js'; +export declare const nullTag: ScalarTag & { + test: RegExp; +}; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/null.js b/MistyCore/node_modules/yaml/dist/schema/common/null.js new file mode 100644 index 0000000..cb353a7 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/null.js @@ -0,0 +1,17 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); + +const nullTag = { + identify: value => value == null, + createNode: () => new Scalar.Scalar(null), + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: () => new Scalar.Scalar(null), + stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source) + ? source + : ctx.options.nullStr +}; + +exports.nullTag = nullTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/seq.d.ts b/MistyCore/node_modules/yaml/dist/schema/common/seq.d.ts new file mode 100644 index 0000000..c038d30 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/seq.d.ts @@ -0,0 +1,2 @@ +import type { CollectionTag } from '../types.js'; +export declare const seq: CollectionTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/seq.js b/MistyCore/node_modules/yaml/dist/schema/common/seq.js new file mode 100644 index 0000000..0c48bde --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/seq.js @@ -0,0 +1,35 @@ +'use strict'; + +var createNode = require('../../doc/createNode.js'); +var Node = require('../../nodes/Node.js'); +var YAMLSeq = require('../../nodes/YAMLSeq.js'); + +function createSeq(schema, obj, ctx) { + const { replacer } = ctx; + const seq = new YAMLSeq.YAMLSeq(schema); + if (obj && Symbol.iterator in Object(obj)) { + let i = 0; + for (let it of obj) { + if (typeof replacer === 'function') { + const key = obj instanceof Set ? it : String(i++); + it = replacer.call(obj, key, it); + } + seq.items.push(createNode.createNode(it, undefined, ctx)); + } + } + return seq; +} +const seq = { + collection: 'seq', + createNode: createSeq, + default: true, + nodeClass: YAMLSeq.YAMLSeq, + tag: 'tag:yaml.org,2002:seq', + resolve(seq, onError) { + if (!Node.isSeq(seq)) + onError('Expected a sequence for this tag'); + return seq; + } +}; + +exports.seq = seq; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/string.d.ts b/MistyCore/node_modules/yaml/dist/schema/common/string.d.ts new file mode 100644 index 0000000..539c9b1 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/string.d.ts @@ -0,0 +1,2 @@ +import type { ScalarTag } from '../types.js'; +export declare const string: ScalarTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/common/string.js b/MistyCore/node_modules/yaml/dist/schema/common/string.js new file mode 100644 index 0000000..7601420 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/common/string.js @@ -0,0 +1,16 @@ +'use strict'; + +var stringifyString = require('../../stringify/stringifyString.js'); + +const string = { + identify: value => typeof value === 'string', + default: true, + tag: 'tag:yaml.org,2002:str', + resolve: str => str, + stringify(item, ctx, onComment, onChompKeep) { + ctx = Object.assign({ actualString: true }, ctx); + return stringifyString.stringifyString(item, ctx, onComment, onChompKeep); + } +}; + +exports.string = string; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/bool.d.ts b/MistyCore/node_modules/yaml/dist/schema/core/bool.d.ts new file mode 100644 index 0000000..e4bdc4c --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/bool.d.ts @@ -0,0 +1,4 @@ +import type { ScalarTag } from '../types.js'; +export declare const boolTag: ScalarTag & { + test: RegExp; +}; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/bool.js b/MistyCore/node_modules/yaml/dist/schema/core/bool.js new file mode 100644 index 0000000..4def73c --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/bool.js @@ -0,0 +1,21 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); + +const boolTag = { + identify: value => typeof value === 'boolean', + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/, + resolve: str => new Scalar.Scalar(str[0] === 't' || str[0] === 'T'), + stringify({ source, value }, ctx) { + if (source && boolTag.test.test(source)) { + const sv = source[0] === 't' || source[0] === 'T'; + if (value === sv) + return source; + } + return value ? ctx.options.trueStr : ctx.options.falseStr; + } +}; + +exports.boolTag = boolTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/float.d.ts b/MistyCore/node_modules/yaml/dist/schema/core/float.d.ts new file mode 100644 index 0000000..22f0249 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/float.d.ts @@ -0,0 +1,4 @@ +import type { ScalarTag } from '../types.js'; +export declare const floatNaN: ScalarTag; +export declare const floatExp: ScalarTag; +export declare const float: ScalarTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/float.js b/MistyCore/node_modules/yaml/dist/schema/core/float.js new file mode 100644 index 0000000..a1c96dd --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/float.js @@ -0,0 +1,47 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); +var stringifyNumber = require('../../stringify/stringifyNumber.js'); + +const floatNaN = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN))$/, + resolve: str => str.slice(-3).toLowerCase() === 'nan' + ? NaN + : str[0] === '-' + ? Number.NEGATIVE_INFINITY + : Number.POSITIVE_INFINITY, + stringify: stringifyNumber.stringifyNumber +}; +const floatExp = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'EXP', + test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/, + resolve: str => parseFloat(str), + stringify(node) { + const num = Number(node.value); + return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node); + } +}; +const float = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/, + resolve(str) { + const node = new Scalar.Scalar(parseFloat(str)); + const dot = str.indexOf('.'); + if (dot !== -1 && str[str.length - 1] === '0') + node.minFractionDigits = str.length - dot - 1; + return node; + }, + stringify: stringifyNumber.stringifyNumber +}; + +exports.float = float; +exports.floatExp = floatExp; +exports.floatNaN = floatNaN; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/int.d.ts b/MistyCore/node_modules/yaml/dist/schema/core/int.d.ts new file mode 100644 index 0000000..35e2d4b --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/int.d.ts @@ -0,0 +1,4 @@ +import type { ScalarTag } from '../types.js'; +export declare const intOct: ScalarTag; +export declare const int: ScalarTag; +export declare const intHex: ScalarTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/int.js b/MistyCore/node_modules/yaml/dist/schema/core/int.js new file mode 100644 index 0000000..fe4c9ca --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/int.js @@ -0,0 +1,42 @@ +'use strict'; + +var stringifyNumber = require('../../stringify/stringifyNumber.js'); + +const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value); +const intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix)); +function intStringify(node, radix, prefix) { + const { value } = node; + if (intIdentify(value) && value >= 0) + return prefix + value.toString(radix); + return stringifyNumber.stringifyNumber(node); +} +const intOct = { + identify: value => intIdentify(value) && value >= 0, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'OCT', + test: /^0o[0-7]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt), + stringify: node => intStringify(node, 8, '0o') +}; +const int = { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^[-+]?[0-9]+$/, + resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), + stringify: stringifyNumber.stringifyNumber +}; +const intHex = { + identify: value => intIdentify(value) && value >= 0, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'HEX', + test: /^0x[0-9a-fA-F]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), + stringify: node => intStringify(node, 16, '0x') +}; + +exports.int = int; +exports.intHex = intHex; +exports.intOct = intOct; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/schema.d.ts b/MistyCore/node_modules/yaml/dist/schema/core/schema.d.ts new file mode 100644 index 0000000..7663949 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/schema.d.ts @@ -0,0 +1 @@ +export declare const schema: (import("../types.js").ScalarTag | import("../types.js").CollectionTag)[]; diff --git a/MistyCore/node_modules/yaml/dist/schema/core/schema.js b/MistyCore/node_modules/yaml/dist/schema/core/schema.js new file mode 100644 index 0000000..6ab87f2 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/core/schema.js @@ -0,0 +1,25 @@ +'use strict'; + +var map = require('../common/map.js'); +var _null = require('../common/null.js'); +var seq = require('../common/seq.js'); +var string = require('../common/string.js'); +var bool = require('./bool.js'); +var float = require('./float.js'); +var int = require('./int.js'); + +const schema = [ + map.map, + seq.seq, + string.string, + _null.nullTag, + bool.boolTag, + int.intOct, + int.int, + int.intHex, + float.floatNaN, + float.floatExp, + float.float +]; + +exports.schema = schema; diff --git a/MistyCore/node_modules/yaml/dist/schema/json-schema.d.ts b/MistyCore/node_modules/yaml/dist/schema/json-schema.d.ts new file mode 100644 index 0000000..20b005d --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/json-schema.d.ts @@ -0,0 +1,69 @@ +declare type JsonSchema = boolean | ArraySchema | ObjectSchema | NumberSchema | StringSchema; +declare type JsonType = 'array' | 'object' | 'string' | 'number' | 'integer' | 'boolean' | 'null'; +interface CommonSchema { + type?: JsonType | JsonType[]; + const?: unknown; + enum?: unknown[]; + format?: string; + allOf?: JsonSchema[]; + anyOf?: JsonSchema[]; + oneOf?: JsonSchema[]; + not?: JsonSchema; + if?: JsonSchema; + then?: JsonSchema; + else?: JsonSchema; + $id?: string; + $defs?: Record<string, JsonSchema>; + $anchor?: string; + $dynamicAnchor?: string; + $ref?: string; + $dynamicRef?: string; + $schema?: string; + $vocabulary?: Record<string, boolean>; + $comment?: string; + default?: unknown; + deprecated?: boolean; + readOnly?: boolean; + writeOnly?: boolean; + title?: string; + description?: string; + examples?: unknown[]; +} +interface ArraySchema extends CommonSchema { + prefixItems?: JsonSchema[]; + items?: JsonSchema; + contains?: JsonSchema; + unevaluatedItems?: JsonSchema; + maxItems?: number; + minItems?: number; + uniqueItems?: boolean; + maxContains?: number; + minContains?: number; +} +interface ObjectSchema extends CommonSchema { + properties?: Record<string, JsonSchema>; + patternProperties?: Record<string, JsonSchema>; + additionalProperties?: JsonSchema; + propertyNames?: JsonSchema; + unevaluatedProperties?: JsonSchema; + maxProperties?: number; + minProperties?: number; + required?: string[]; + dependentRequired?: Record<string, string[]>; + dependentSchemas?: Record<string, JsonSchema>; +} +interface StringSchema extends CommonSchema { + maxLength?: number; + minLength?: number; + patter?: string; + contentEncoding?: string; + contentMediaType?: string; + contentSchema?: JsonSchema; +} +interface NumberSchema extends CommonSchema { + multipleOf?: number; + maximum?: number; + exclusiveMaximum?: number; + minimum?: number; + exclusiveMinimum?: number; +} diff --git a/MistyCore/node_modules/yaml/dist/schema/json/schema.d.ts b/MistyCore/node_modules/yaml/dist/schema/json/schema.d.ts new file mode 100644 index 0000000..a166ca2 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/json/schema.d.ts @@ -0,0 +1,2 @@ +import { CollectionTag, ScalarTag } from '../types.js'; +export declare const schema: (ScalarTag | CollectionTag)[]; diff --git a/MistyCore/node_modules/yaml/dist/schema/json/schema.js b/MistyCore/node_modules/yaml/dist/schema/json/schema.js new file mode 100644 index 0000000..31d0b4d --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/json/schema.js @@ -0,0 +1,64 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); +var map = require('../common/map.js'); +var seq = require('../common/seq.js'); + +function intIdentify(value) { + return typeof value === 'bigint' || Number.isInteger(value); +} +const stringifyJSON = ({ value }) => JSON.stringify(value); +const jsonScalars = [ + { + identify: value => typeof value === 'string', + default: true, + tag: 'tag:yaml.org,2002:str', + resolve: str => str, + stringify: stringifyJSON + }, + { + identify: value => value == null, + createNode: () => new Scalar.Scalar(null), + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^null$/, + resolve: () => null, + stringify: stringifyJSON + }, + { + identify: value => typeof value === 'boolean', + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^true|false$/, + resolve: str => str === 'true', + stringify: stringifyJSON + }, + { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^-?(?:0|[1-9][0-9]*)$/, + resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10), + stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value) + }, + { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, + resolve: str => parseFloat(str), + stringify: stringifyJSON + } +]; +const jsonError = { + default: true, + tag: '', + test: /^/, + resolve(str, onError) { + onError(`Unresolved plain scalar ${JSON.stringify(str)}`); + return str; + } +}; +const schema = [map.map, seq.seq].concat(jsonScalars, jsonError); + +exports.schema = schema; diff --git a/MistyCore/node_modules/yaml/dist/schema/tags.d.ts b/MistyCore/node_modules/yaml/dist/schema/tags.d.ts new file mode 100644 index 0000000..8b4acf2 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/tags.d.ts @@ -0,0 +1,40 @@ +import { SchemaOptions } from '../options.js'; +import type { CollectionTag, ScalarTag } from './types.js'; +declare const tagsByName: { + binary: ScalarTag; + bool: ScalarTag & { + test: RegExp; + }; + float: ScalarTag; + floatExp: ScalarTag; + floatNaN: ScalarTag; + floatTime: ScalarTag; + int: ScalarTag; + intHex: ScalarTag; + intOct: ScalarTag; + intTime: ScalarTag; + map: CollectionTag; + null: ScalarTag & { + test: RegExp; + }; + omap: CollectionTag; + pairs: CollectionTag; + seq: CollectionTag; + set: CollectionTag; + timestamp: ScalarTag & { + test: RegExp; + }; +}; +export declare type TagId = keyof typeof tagsByName; +export declare type Tags = Array<ScalarTag | CollectionTag | TagId>; +export declare const coreKnownTags: { + 'tag:yaml.org,2002:binary': ScalarTag; + 'tag:yaml.org,2002:omap': CollectionTag; + 'tag:yaml.org,2002:pairs': CollectionTag; + 'tag:yaml.org,2002:set': CollectionTag; + 'tag:yaml.org,2002:timestamp': ScalarTag & { + test: RegExp; + }; +}; +export declare function getTags(customTags: SchemaOptions['customTags'] | undefined, schemaName: string): (ScalarTag | CollectionTag)[]; +export {}; diff --git a/MistyCore/node_modules/yaml/dist/schema/tags.js b/MistyCore/node_modules/yaml/dist/schema/tags.js new file mode 100644 index 0000000..e49d2b0 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/tags.js @@ -0,0 +1,86 @@ +'use strict'; + +var map = require('./common/map.js'); +var _null = require('./common/null.js'); +var seq = require('./common/seq.js'); +var string = require('./common/string.js'); +var bool = require('./core/bool.js'); +var float = require('./core/float.js'); +var int = require('./core/int.js'); +var schema = require('./core/schema.js'); +var schema$1 = require('./json/schema.js'); +var binary = require('./yaml-1.1/binary.js'); +var omap = require('./yaml-1.1/omap.js'); +var pairs = require('./yaml-1.1/pairs.js'); +var schema$2 = require('./yaml-1.1/schema.js'); +var set = require('./yaml-1.1/set.js'); +var timestamp = require('./yaml-1.1/timestamp.js'); + +const schemas = new Map([ + ['core', schema.schema], + ['failsafe', [map.map, seq.seq, string.string]], + ['json', schema$1.schema], + ['yaml11', schema$2.schema], + ['yaml-1.1', schema$2.schema] +]); +const tagsByName = { + binary: binary.binary, + bool: bool.boolTag, + float: float.float, + floatExp: float.floatExp, + floatNaN: float.floatNaN, + floatTime: timestamp.floatTime, + int: int.int, + intHex: int.intHex, + intOct: int.intOct, + intTime: timestamp.intTime, + map: map.map, + null: _null.nullTag, + omap: omap.omap, + pairs: pairs.pairs, + seq: seq.seq, + set: set.set, + timestamp: timestamp.timestamp +}; +const coreKnownTags = { + 'tag:yaml.org,2002:binary': binary.binary, + 'tag:yaml.org,2002:omap': omap.omap, + 'tag:yaml.org,2002:pairs': pairs.pairs, + 'tag:yaml.org,2002:set': set.set, + 'tag:yaml.org,2002:timestamp': timestamp.timestamp +}; +function getTags(customTags, schemaName) { + let tags = schemas.get(schemaName); + if (!tags) { + if (Array.isArray(customTags)) + tags = []; + else { + const keys = Array.from(schemas.keys()) + .filter(key => key !== 'yaml11') + .map(key => JSON.stringify(key)) + .join(', '); + throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`); + } + } + if (Array.isArray(customTags)) { + for (const tag of customTags) + tags = tags.concat(tag); + } + else if (typeof customTags === 'function') { + tags = customTags(tags.slice()); + } + return tags.map(tag => { + if (typeof tag !== 'string') + return tag; + const tagObj = tagsByName[tag]; + if (tagObj) + return tagObj; + const keys = Object.keys(tagsByName) + .map(key => JSON.stringify(key)) + .join(', '); + throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`); + }); +} + +exports.coreKnownTags = coreKnownTags; +exports.getTags = getTags; diff --git a/MistyCore/node_modules/yaml/dist/schema/types.d.ts b/MistyCore/node_modules/yaml/dist/schema/types.d.ts new file mode 100644 index 0000000..13e8354 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/types.d.ts @@ -0,0 +1,82 @@ +import type { CreateNodeContext } from '../doc/createNode.js'; +import type { Schema } from './Schema.js'; +import type { Node } from '../nodes/Node.js'; +import type { Scalar } from '../nodes/Scalar.js'; +import type { YAMLMap } from '../nodes/YAMLMap.js'; +import type { YAMLSeq } from '../nodes/YAMLSeq.js'; +import type { ParseOptions } from '../options.js'; +import type { StringifyContext } from '../stringify/stringify.js'; +interface TagBase { + /** + * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes. + */ + createNode?: (schema: Schema, value: unknown, ctx: CreateNodeContext) => Node; + /** + * If `true`, together with `test` allows for values to be stringified without + * an explicit tag. For most cases, it's unlikely that you'll actually want to + * use this, even if you first think you do. + */ + default: boolean; + /** + * If a tag has multiple forms that should be parsed and/or stringified + * differently, use `format` to identify them. + */ + format?: string; + /** + * Used by `YAML.createNode` to detect your data type, e.g. using `typeof` or + * `instanceof`. + */ + identify?: (value: unknown) => boolean; + /** + * The identifier for your data type, with which its stringified form will be + * prefixed. Should either be a !-prefixed local `!tag`, or a fully qualified + * `tag:domain,date:foo`. + */ + tag: string; +} +export interface ScalarTag extends TagBase { + collection?: never; + nodeClass?: never; + /** + * Turns a value into an AST node. + * If returning a non-`Node` value, the output will be wrapped as a `Scalar`. + */ + resolve(value: string, onError: (message: string) => void, options: ParseOptions): unknown; + /** + * Optional function stringifying a Scalar node. If your data includes a + * suitable `.toString()` method, you can probably leave this undefined and + * use the default stringifier. + * + * @param item The node being stringified. + * @param ctx Contains the stringifying context variables. + * @param onComment Callback to signal that the stringifier includes the + * item's comment in its output. + * @param onChompKeep Callback to signal that the output uses a block scalar + * type with the `+` chomping indicator. + */ + stringify?: (item: Scalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void) => string; + /** + * Together with `default` allows for values to be stringified without an + * explicit tag and detected using a regular expression. For most cases, it's + * unlikely that you'll actually want to use these, even if you first think + * you do. + */ + test?: RegExp; +} +export interface CollectionTag extends TagBase { + stringify?: never; + test?: never; + /** The source collection type supported by this tag. */ + collection: 'map' | 'seq'; + /** + * The `Node` child class that implements this tag. + * If set, used to select this tag when stringifying. + */ + nodeClass?: new () => Node; + /** + * Turns a value into an AST node. + * If returning a non-`Node` value, the output will be wrapped as a `Scalar`. + */ + resolve(value: YAMLMap.Parsed | YAMLSeq.Parsed, onError: (message: string) => void, options: ParseOptions): unknown; +} +export {}; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/binary.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/binary.d.ts new file mode 100644 index 0000000..2054970 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/binary.d.ts @@ -0,0 +1,2 @@ +import type { ScalarTag } from '../types.js'; +export declare const binary: ScalarTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/binary.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/binary.js new file mode 100644 index 0000000..df93e05 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/binary.js @@ -0,0 +1,68 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); +var stringifyString = require('../../stringify/stringifyString.js'); + +const binary = { + identify: value => value instanceof Uint8Array, + default: false, + tag: 'tag:yaml.org,2002:binary', + /** + * Returns a Buffer in node and an Uint8Array in browsers + * + * To use the resulting buffer as an image, you'll want to do something like: + * + * const blob = new Blob([buffer], { type: 'image/jpeg' }) + * document.querySelector('#photo').src = URL.createObjectURL(blob) + */ + resolve(src, onError) { + if (typeof Buffer === 'function') { + return Buffer.from(src, 'base64'); + } + else if (typeof atob === 'function') { + // On IE 11, atob() can't handle newlines + const str = atob(src.replace(/[\n\r]/g, '')); + const buffer = new Uint8Array(str.length); + for (let i = 0; i < str.length; ++i) + buffer[i] = str.charCodeAt(i); + return buffer; + } + else { + onError('This environment does not support reading binary tags; either Buffer or atob is required'); + return src; + } + }, + stringify({ comment, type, value }, ctx, onComment, onChompKeep) { + const buf = value; // checked earlier by binary.identify() + let str; + if (typeof Buffer === 'function') { + str = + buf instanceof Buffer + ? buf.toString('base64') + : Buffer.from(buf.buffer).toString('base64'); + } + else if (typeof btoa === 'function') { + let s = ''; + for (let i = 0; i < buf.length; ++i) + s += String.fromCharCode(buf[i]); + str = btoa(s); + } + else { + throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required'); + } + if (!type) + type = Scalar.Scalar.BLOCK_LITERAL; + if (type !== Scalar.Scalar.QUOTE_DOUBLE) { + const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth); + const n = Math.ceil(str.length / lineWidth); + const lines = new Array(n); + for (let i = 0, o = 0; i < n; ++i, o += lineWidth) { + lines[i] = str.substr(o, lineWidth); + } + str = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? '\n' : ' '); + } + return stringifyString.stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep); + } +}; + +exports.binary = binary; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/bool.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/bool.d.ts new file mode 100644 index 0000000..587b55b --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/bool.d.ts @@ -0,0 +1,7 @@ +import type { ScalarTag } from '../types.js'; +export declare const trueTag: ScalarTag & { + test: RegExp; +}; +export declare const falseTag: ScalarTag & { + test: RegExp; +}; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/bool.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/bool.js new file mode 100644 index 0000000..fdb3b46 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/bool.js @@ -0,0 +1,29 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); + +function boolStringify({ value, source }, ctx) { + const boolObj = value ? trueTag : falseTag; + if (source && boolObj.test.test(source)) + return source; + return value ? ctx.options.trueStr : ctx.options.falseStr; +} +const trueTag = { + identify: value => value === true, + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/, + resolve: () => new Scalar.Scalar(true), + stringify: boolStringify +}; +const falseTag = { + identify: value => value === false, + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i, + resolve: () => new Scalar.Scalar(false), + stringify: boolStringify +}; + +exports.falseTag = falseTag; +exports.trueTag = trueTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/float.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/float.d.ts new file mode 100644 index 0000000..22f0249 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/float.d.ts @@ -0,0 +1,4 @@ +import type { ScalarTag } from '../types.js'; +export declare const floatNaN: ScalarTag; +export declare const floatExp: ScalarTag; +export declare const float: ScalarTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/float.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/float.js new file mode 100644 index 0000000..4aea19a --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/float.js @@ -0,0 +1,50 @@ +'use strict'; + +var Scalar = require('../../nodes/Scalar.js'); +var stringifyNumber = require('../../stringify/stringifyNumber.js'); + +const floatNaN = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN)$/, + resolve: (str) => str.slice(-3).toLowerCase() === 'nan' + ? NaN + : str[0] === '-' + ? Number.NEGATIVE_INFINITY + : Number.POSITIVE_INFINITY, + stringify: stringifyNumber.stringifyNumber +}; +const floatExp = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'EXP', + test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str.replace(/_/g, '')), + stringify(node) { + const num = Number(node.value); + return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node); + } +}; +const float = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/, + resolve(str) { + const node = new Scalar.Scalar(parseFloat(str.replace(/_/g, ''))); + const dot = str.indexOf('.'); + if (dot !== -1) { + const f = str.substring(dot + 1).replace(/_/g, ''); + if (f[f.length - 1] === '0') + node.minFractionDigits = f.length; + } + return node; + }, + stringify: stringifyNumber.stringifyNumber +}; + +exports.float = float; +exports.floatExp = floatExp; +exports.floatNaN = floatNaN; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/int.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/int.d.ts new file mode 100644 index 0000000..3d92f37 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/int.d.ts @@ -0,0 +1,5 @@ +import type { ScalarTag } from '../types.js'; +export declare const intBin: ScalarTag; +export declare const intOct: ScalarTag; +export declare const int: ScalarTag; +export declare const intHex: ScalarTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/int.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/int.js new file mode 100644 index 0000000..fdf47ca --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/int.js @@ -0,0 +1,76 @@ +'use strict'; + +var stringifyNumber = require('../../stringify/stringifyNumber.js'); + +const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value); +function intResolve(str, offset, radix, { intAsBigInt }) { + const sign = str[0]; + if (sign === '-' || sign === '+') + offset += 1; + str = str.substring(offset).replace(/_/g, ''); + if (intAsBigInt) { + switch (radix) { + case 2: + str = `0b${str}`; + break; + case 8: + str = `0o${str}`; + break; + case 16: + str = `0x${str}`; + break; + } + const n = BigInt(str); + return sign === '-' ? BigInt(-1) * n : n; + } + const n = parseInt(str, radix); + return sign === '-' ? -1 * n : n; +} +function intStringify(node, radix, prefix) { + const { value } = node; + if (intIdentify(value)) { + const str = value.toString(radix); + return value < 0 ? '-' + prefix + str.substr(1) : prefix + str; + } + return stringifyNumber.stringifyNumber(node); +} +const intBin = { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'BIN', + test: /^[-+]?0b[0-1_]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt), + stringify: node => intStringify(node, 2, '0b') +}; +const intOct = { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'OCT', + test: /^[-+]?0[0-7_]+$/, + resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt), + stringify: node => intStringify(node, 8, '0') +}; +const int = { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^[-+]?[0-9][0-9_]*$/, + resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), + stringify: stringifyNumber.stringifyNumber +}; +const intHex = { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'HEX', + test: /^[-+]?0x[0-9a-fA-F_]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), + stringify: node => intStringify(node, 16, '0x') +}; + +exports.int = int; +exports.intBin = intBin; +exports.intHex = intHex; +exports.intOct = intOct; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/omap.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/omap.d.ts new file mode 100644 index 0000000..a5a37cd --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/omap.d.ts @@ -0,0 +1,25 @@ +import { YAMLSeq } from '../../nodes/YAMLSeq.js'; +import { ToJSContext } from '../../nodes/toJS.js'; +import { CollectionTag } from '../types.js'; +export declare class YAMLOMap extends YAMLSeq { + static tag: string; + constructor(); + add: (pair: import("../../index.js").Pair<any, any> | { + key: any; + value: any; + }, overwrite?: boolean | undefined) => void; + delete: (key: unknown) => boolean; + get: { + (key: unknown, keepScalar: true): import("../../index.js").Scalar<any> | undefined; + (key: unknown, keepScalar?: false | undefined): any; + (key: unknown, keepScalar?: boolean | undefined): any; + }; + has: (key: unknown) => boolean; + set: (key: any, value: any) => void; + /** + * If `ctx` is given, the return type is actually `Map<unknown, unknown>`, + * but TypeScript won't allow widening the signature of a child method. + */ + toJSON(_?: unknown, ctx?: ToJSContext): unknown[]; +} +export declare const omap: CollectionTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/omap.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/omap.js new file mode 100644 index 0000000..eb69d5a --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/omap.js @@ -0,0 +1,76 @@ +'use strict'; + +var YAMLSeq = require('../../nodes/YAMLSeq.js'); +var toJS = require('../../nodes/toJS.js'); +var Node = require('../../nodes/Node.js'); +var YAMLMap = require('../../nodes/YAMLMap.js'); +var pairs = require('./pairs.js'); + +class YAMLOMap extends YAMLSeq.YAMLSeq { + constructor() { + super(); + this.add = YAMLMap.YAMLMap.prototype.add.bind(this); + this.delete = YAMLMap.YAMLMap.prototype.delete.bind(this); + this.get = YAMLMap.YAMLMap.prototype.get.bind(this); + this.has = YAMLMap.YAMLMap.prototype.has.bind(this); + this.set = YAMLMap.YAMLMap.prototype.set.bind(this); + this.tag = YAMLOMap.tag; + } + /** + * If `ctx` is given, the return type is actually `Map<unknown, unknown>`, + * but TypeScript won't allow widening the signature of a child method. + */ + toJSON(_, ctx) { + if (!ctx) + return super.toJSON(_); + const map = new Map(); + if (ctx?.onCreate) + ctx.onCreate(map); + for (const pair of this.items) { + let key, value; + if (Node.isPair(pair)) { + key = toJS.toJS(pair.key, '', ctx); + value = toJS.toJS(pair.value, key, ctx); + } + else { + key = toJS.toJS(pair, '', ctx); + } + if (map.has(key)) + throw new Error('Ordered maps must not include duplicate keys'); + map.set(key, value); + } + return map; + } +} +YAMLOMap.tag = 'tag:yaml.org,2002:omap'; +const omap = { + collection: 'seq', + identify: value => value instanceof Map, + nodeClass: YAMLOMap, + default: false, + tag: 'tag:yaml.org,2002:omap', + resolve(seq, onError) { + const pairs$1 = pairs.resolvePairs(seq, onError); + const seenKeys = []; + for (const { key } of pairs$1.items) { + if (Node.isScalar(key)) { + if (seenKeys.includes(key.value)) { + onError(`Ordered maps must not include duplicate keys: ${key.value}`); + } + else { + seenKeys.push(key.value); + } + } + } + return Object.assign(new YAMLOMap(), pairs$1); + }, + createNode(schema, iterable, ctx) { + const pairs$1 = pairs.createPairs(schema, iterable, ctx); + const omap = new YAMLOMap(); + omap.items = pairs$1.items; + return omap; + } +}; + +exports.YAMLOMap = YAMLOMap; +exports.omap = omap; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/pairs.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/pairs.d.ts new file mode 100644 index 0000000..8090ac2 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/pairs.d.ts @@ -0,0 +1,10 @@ +import type { CreateNodeContext } from '../../doc/createNode.js'; +import { ParsedNode } from '../../nodes/Node.js'; +import { Pair } from '../../nodes/Pair.js'; +import { YAMLMap } from '../../nodes/YAMLMap.js'; +import { YAMLSeq } from '../../nodes/YAMLSeq.js'; +import type { Schema } from '../../schema/Schema.js'; +import type { CollectionTag } from '../types.js'; +export declare function resolvePairs(seq: YAMLSeq.Parsed<ParsedNode | Pair<ParsedNode, ParsedNode | null>> | YAMLMap.Parsed, onError: (message: string) => void): YAMLSeq.Parsed<Pair<ParsedNode, ParsedNode | null>>; +export declare function createPairs(schema: Schema, iterable: unknown, ctx: CreateNodeContext): YAMLSeq<unknown>; +export declare const pairs: CollectionTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/pairs.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/pairs.js new file mode 100644 index 0000000..d27d34d --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/pairs.js @@ -0,0 +1,81 @@ +'use strict'; + +var Node = require('../../nodes/Node.js'); +var Pair = require('../../nodes/Pair.js'); +var Scalar = require('../../nodes/Scalar.js'); +var YAMLSeq = require('../../nodes/YAMLSeq.js'); + +function resolvePairs(seq, onError) { + if (Node.isSeq(seq)) { + for (let i = 0; i < seq.items.length; ++i) { + let item = seq.items[i]; + if (Node.isPair(item)) + continue; + else if (Node.isMap(item)) { + if (item.items.length > 1) + onError('Each pair must have its own sequence indicator'); + const pair = item.items[0] || new Pair.Pair(new Scalar.Scalar(null)); + if (item.commentBefore) + pair.key.commentBefore = pair.key.commentBefore + ? `${item.commentBefore}\n${pair.key.commentBefore}` + : item.commentBefore; + if (item.comment) { + const cn = pair.value ?? pair.key; + cn.comment = cn.comment + ? `${item.comment}\n${cn.comment}` + : item.comment; + } + item = pair; + } + seq.items[i] = Node.isPair(item) ? item : new Pair.Pair(item); + } + } + else + onError('Expected a sequence for this tag'); + return seq; +} +function createPairs(schema, iterable, ctx) { + const { replacer } = ctx; + const pairs = new YAMLSeq.YAMLSeq(schema); + pairs.tag = 'tag:yaml.org,2002:pairs'; + let i = 0; + if (iterable && Symbol.iterator in Object(iterable)) + for (let it of iterable) { + if (typeof replacer === 'function') + it = replacer.call(iterable, String(i++), it); + let key, value; + if (Array.isArray(it)) { + if (it.length === 2) { + key = it[0]; + value = it[1]; + } + else + throw new TypeError(`Expected [key, value] tuple: ${it}`); + } + else if (it && it instanceof Object) { + const keys = Object.keys(it); + if (keys.length === 1) { + key = keys[0]; + value = it[key]; + } + else + throw new TypeError(`Expected { key: value } tuple: ${it}`); + } + else { + key = it; + } + pairs.items.push(Pair.createPair(key, value, ctx)); + } + return pairs; +} +const pairs = { + collection: 'seq', + default: false, + tag: 'tag:yaml.org,2002:pairs', + resolve: resolvePairs, + createNode: createPairs +}; + +exports.createPairs = createPairs; +exports.pairs = pairs; +exports.resolvePairs = resolvePairs; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/schema.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/schema.d.ts new file mode 100644 index 0000000..7663949 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/schema.d.ts @@ -0,0 +1 @@ +export declare const schema: (import("../types.js").ScalarTag | import("../types.js").CollectionTag)[]; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/schema.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/schema.js new file mode 100644 index 0000000..c04270a --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/schema.js @@ -0,0 +1,39 @@ +'use strict'; + +var map = require('../common/map.js'); +var _null = require('../common/null.js'); +var seq = require('../common/seq.js'); +var string = require('../common/string.js'); +var binary = require('./binary.js'); +var bool = require('./bool.js'); +var float = require('./float.js'); +var int = require('./int.js'); +var omap = require('./omap.js'); +var pairs = require('./pairs.js'); +var set = require('./set.js'); +var timestamp = require('./timestamp.js'); + +const schema = [ + map.map, + seq.seq, + string.string, + _null.nullTag, + bool.trueTag, + bool.falseTag, + int.intBin, + int.intOct, + int.int, + int.intHex, + float.floatNaN, + float.floatExp, + float.float, + binary.binary, + omap.omap, + pairs.pairs, + set.set, + timestamp.intTime, + timestamp.floatTime, + timestamp.timestamp +]; + +exports.schema = schema; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/set.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/set.d.ts new file mode 100644 index 0000000..068f582 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/set.d.ts @@ -0,0 +1,26 @@ +import type { Schema } from '../../schema/Schema.js'; +import { Pair } from '../../nodes/Pair.js'; +import { Scalar } from '../../nodes/Scalar.js'; +import { ToJSContext } from '../../nodes/toJS.js'; +import { YAMLMap } from '../../nodes/YAMLMap.js'; +import type { StringifyContext } from '../../stringify/stringify.js'; +import type { CollectionTag } from '../types.js'; +export declare class YAMLSet<T = unknown> extends YAMLMap<T, Scalar<null> | null> { + static tag: string; + constructor(schema?: Schema); + add(key: T | Pair<T, Scalar<null> | null> | { + key: T; + value: Scalar<null> | null; + }): void; + /** + * If `keepPair` is `true`, returns the Pair matching `key`. + * Otherwise, returns the value of that Pair's key. + */ + get(key: unknown, keepPair?: boolean): any; + set(key: T, value: boolean): void; + /** @deprecated Will throw; `value` must be boolean */ + set(key: T, value: null): void; + toJSON(_?: unknown, ctx?: ToJSContext): any; + toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string; +} +export declare const set: CollectionTag; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/set.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/set.js new file mode 100644 index 0000000..c288a37 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/set.js @@ -0,0 +1,95 @@ +'use strict'; + +var Node = require('../../nodes/Node.js'); +var Pair = require('../../nodes/Pair.js'); +var YAMLMap = require('../../nodes/YAMLMap.js'); + +class YAMLSet extends YAMLMap.YAMLMap { + constructor(schema) { + super(schema); + this.tag = YAMLSet.tag; + } + add(key) { + let pair; + if (Node.isPair(key)) + pair = key; + else if (key && + typeof key === 'object' && + 'key' in key && + 'value' in key && + key.value === null) + pair = new Pair.Pair(key.key, null); + else + pair = new Pair.Pair(key, null); + const prev = YAMLMap.findPair(this.items, pair.key); + if (!prev) + this.items.push(pair); + } + /** + * If `keepPair` is `true`, returns the Pair matching `key`. + * Otherwise, returns the value of that Pair's key. + */ + get(key, keepPair) { + const pair = YAMLMap.findPair(this.items, key); + return !keepPair && Node.isPair(pair) + ? Node.isScalar(pair.key) + ? pair.key.value + : pair.key + : pair; + } + set(key, value) { + if (typeof value !== 'boolean') + throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`); + const prev = YAMLMap.findPair(this.items, key); + if (prev && !value) { + this.items.splice(this.items.indexOf(prev), 1); + } + else if (!prev && value) { + this.items.push(new Pair.Pair(key)); + } + } + toJSON(_, ctx) { + return super.toJSON(_, ctx, Set); + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + if (this.hasAllNullValues(true)) + return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep); + else + throw new Error('Set items must all have null values'); + } +} +YAMLSet.tag = 'tag:yaml.org,2002:set'; +const set = { + collection: 'map', + identify: value => value instanceof Set, + nodeClass: YAMLSet, + default: false, + tag: 'tag:yaml.org,2002:set', + resolve(map, onError) { + if (Node.isMap(map)) { + if (map.hasAllNullValues(true)) + return Object.assign(new YAMLSet(), map); + else + onError('Set items must all have null values'); + } + else + onError('Expected a mapping for this tag'); + return map; + }, + createNode(schema, iterable, ctx) { + const { replacer } = ctx; + const set = new YAMLSet(schema); + if (iterable && Symbol.iterator in Object(iterable)) + for (let value of iterable) { + if (typeof replacer === 'function') + value = replacer.call(iterable, value, value); + set.items.push(Pair.createPair(value, null, ctx)); + } + return set; + } +}; + +exports.YAMLSet = YAMLSet; +exports.set = set; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/timestamp.d.ts b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/timestamp.d.ts new file mode 100644 index 0000000..0c1d2d4 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/timestamp.d.ts @@ -0,0 +1,6 @@ +import type { ScalarTag } from '../types.js'; +export declare const intTime: ScalarTag; +export declare const floatTime: ScalarTag; +export declare const timestamp: ScalarTag & { + test: RegExp; +}; diff --git a/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js new file mode 100644 index 0000000..2d78ae8 --- /dev/null +++ b/MistyCore/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js @@ -0,0 +1,105 @@ +'use strict'; + +var stringifyNumber = require('../../stringify/stringifyNumber.js'); + +/** Internal types handle bigint as number, because TS can't figure it out. */ +function parseSexagesimal(str, asBigInt) { + const sign = str[0]; + const parts = sign === '-' || sign === '+' ? str.substring(1) : str; + const num = (n) => asBigInt ? BigInt(n) : Number(n); + const res = parts + .replace(/_/g, '') + .split(':') + .reduce((res, p) => res * num(60) + num(p), num(0)); + return (sign === '-' ? num(-1) * res : res); +} +/** + * hhhh:mm:ss.sss + * + * Internal types handle bigint as number, because TS can't figure it out. + */ +function stringifySexagesimal(node) { + let { value } = node; + let num = (n) => n; + if (typeof value === 'bigint') + num = n => BigInt(n); + else if (isNaN(value) || !isFinite(value)) + return stringifyNumber.stringifyNumber(node); + let sign = ''; + if (value < 0) { + sign = '-'; + value *= num(-1); + } + const _60 = num(60); + const parts = [value % _60]; // seconds, including ms + if (value < 60) { + parts.unshift(0); // at least one : is required + } + else { + value = (value - parts[0]) / _60; + parts.unshift(value % _60); // minutes + if (value >= 60) { + value = (value - parts[0]) / _60; + parts.unshift(value); // hours + } + } + return (sign + + parts + .map(n => (n < 10 ? '0' + String(n) : String(n))) + .join(':') + .replace(/000000\d*$/, '') // % 60 may introduce error + ); +} +const intTime = { + identify: value => typeof value === 'bigint' || Number.isInteger(value), + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'TIME', + test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/, + resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt), + stringify: stringifySexagesimal +}; +const floatTime = { + identify: value => typeof value === 'number', + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'TIME', + test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/, + resolve: str => parseSexagesimal(str, false), + stringify: stringifySexagesimal +}; +const timestamp = { + identify: value => value instanceof Date, + default: true, + tag: 'tag:yaml.org,2002:timestamp', + // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part + // may be omitted altogether, resulting in a date format. In such a case, the time part is + // assumed to be 00:00:00Z (start of day, UTC). + test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd + '(?:' + // time is optional + '(?:t|T|[ \\t]+)' + // t | T | whitespace + '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)? + '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30 + ')?$'), + resolve(str) { + const match = str.match(timestamp.test); + if (!match) + throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd'); + const [, year, month, day, hour, minute, second] = match.map(Number); + const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0; + let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec); + const tz = match[8]; + if (tz && tz !== 'Z') { + let d = parseSexagesimal(tz, false); + if (Math.abs(d) < 30) + d *= 60; + date -= 60000 * d; + } + return new Date(date); + }, + stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, '') +}; + +exports.floatTime = floatTime; +exports.intTime = intTime; +exports.timestamp = timestamp; |