trusty-cms 4.1.1 → 4.1.6

data/spec/spec/dummy/node_modules/yaml/dist/tags/failsafe/seq.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _parseSeq = _interopRequireDefault(require("../../schema/parseSeq"));
+
+var _Seq = _interopRequireDefault(require("../../schema/Seq"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createSeq(schema, obj, ctx) {
+  const seq = new _Seq.default(schema);
+
+  if (obj && obj[Symbol.iterator]) {
+    for (const it of obj) {
+      const v = schema.createNode(it, ctx.wrapScalars, null, ctx);
+      seq.items.push(v);
+    }
+  }
+
+  return seq;
+}
+
+var _default = {
+  createNode: createSeq,
+  default: true,
+  nodeClass: _Seq.default,
+  tag: 'tag:yaml.org,2002:seq',
+  resolve: _parseSeq.default
+};
+exports.default = _default;

data/spec/spec/dummy/node_modules/yaml/dist/tags/failsafe/string.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.resolveString = void 0;
+
+var _stringify = require("../../stringify");
+
+var _options = require("../options");
+
+const resolveString = (doc, node) => {
+  // on error, will return { str: string, errors: Error[] }
+  const res = node.strValue;
+  if (!res) return '';
+  if (typeof res === 'string') return res;
+  res.errors.forEach(error => {
+    if (!error.source) error.source = node;
+    doc.errors.push(error);
+  });
+  return res.str;
+};
+
+exports.resolveString = resolveString;
+var _default = {
+  identify: value => typeof value === 'string',
+  default: true,
+  tag: 'tag:yaml.org,2002:str',
+  resolve: resolveString,
+
+  stringify(item, ctx, onComment, onChompKeep) {
+    ctx = Object.assign({
+      actualString: true
+    }, ctx);
+    return (0, _stringify.stringifyString)(item, ctx, onComment, onChompKeep);
+  },
+
+  options: _options.strOptions
+};
+exports.default = _default;

data/spec/spec/dummy/node_modules/yaml/dist/tags/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tags = exports.schemas = void 0;
+
+var _core = _interopRequireWildcard(require("./core"));
+
+var _failsafe = _interopRequireDefault(require("./failsafe"));
+
+var _json = _interopRequireDefault(require("./json"));
+
+var _yaml = _interopRequireDefault(require("./yaml-1.1"));
+
+var _map = _interopRequireDefault(require("./failsafe/map"));
+
+var _seq = _interopRequireDefault(require("./failsafe/seq"));
+
+var _binary = _interopRequireDefault(require("./yaml-1.1/binary"));
+
+var _omap = _interopRequireDefault(require("./yaml-1.1/omap"));
+
+var _pairs = _interopRequireDefault(require("./yaml-1.1/pairs"));
+
+var _set = _interopRequireDefault(require("./yaml-1.1/set"));
+
+var _timestamp = require("./yaml-1.1/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const schemas = {
+  core: _core.default,
+  failsafe: _failsafe.default,
+  json: _json.default,
+  yaml11: _yaml.default
+};
+exports.schemas = schemas;
+const tags = {
+  binary: _binary.default,
+  bool: _core.boolObj,
+  float: _core.floatObj,
+  floatExp: _core.expObj,
+  floatNaN: _core.nanObj,
+  floatTime: _timestamp.floatTime,
+  int: _core.intObj,
+  intHex: _core.hexObj,
+  intOct: _core.octObj,
+  intTime: _timestamp.intTime,
+  map: _map.default,
+  null: _core.nullObj,
+  omap: _omap.default,
+  pairs: _pairs.default,
+  seq: _seq.default,
+  set: _set.default,
+  timestamp: _timestamp.timestamp
+};
+exports.tags = tags;

data/spec/spec/dummy/node_modules/yaml/dist/tags/json.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _map = _interopRequireDefault(require("./failsafe/map"));
+
+var _seq = _interopRequireDefault(require("./failsafe/seq"));
+
+var _Scalar = _interopRequireDefault(require("../schema/Scalar"));
+
+var _string = require("./failsafe/string");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const schema = [_map.default, _seq.default, {
+  identify: value => typeof value === 'string',
+  default: true,
+  tag: 'tag:yaml.org,2002:str',
+  resolve: _string.resolveString,
+  stringify: value => JSON.stringify(value)
+}, {
+  identify: value => value == null,
+  createNode: (schema, value, ctx) => ctx.wrapScalars ? new _Scalar.default(null) : null,
+  default: true,
+  tag: 'tag:yaml.org,2002:null',
+  test: /^null$/,
+  resolve: () => null,
+  stringify: value => JSON.stringify(value)
+}, {
+  identify: value => typeof value === 'boolean',
+  default: true,
+  tag: 'tag:yaml.org,2002:bool',
+  test: /^true|false$/,
+  resolve: str => str === 'true',
+  stringify: value => JSON.stringify(value)
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  test: /^-?(?:0|[1-9][0-9]*)$/,
+  resolve: str => parseInt(str, 10),
+  stringify: value => 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: value => JSON.stringify(value)
+}];
+
+schema.scalarFallback = str => {
+  throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+};
+
+var _default = schema;
+exports.default = _default;

data/spec/spec/dummy/node_modules/yaml/dist/tags/options.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.strOptions = exports.nullOptions = exports.boolOptions = exports.binaryOptions = void 0;
+
+var _constants = require("../constants");
+
+const binaryOptions = {
+  defaultType: _constants.Type.BLOCK_LITERAL,
+  lineWidth: 76
+};
+exports.binaryOptions = binaryOptions;
+const boolOptions = {
+  trueStr: 'true',
+  falseStr: 'false'
+};
+exports.boolOptions = boolOptions;
+const nullOptions = {
+  nullStr: 'null'
+};
+exports.nullOptions = nullOptions;
+const strOptions = {
+  defaultType: _constants.Type.PLAIN,
+  doubleQuoted: {
+    jsonEncoding: false,
+    minMultiLineLength: 40
+  },
+  fold: {
+    lineWidth: 80,
+    minContentWidth: 20
+  }
+};
+exports.strOptions = strOptions;

data/spec/spec/dummy/node_modules/yaml/dist/tags/yaml-1.1/binary.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../../constants");
+
+var _errors = require("../../errors");
+
+var _stringify = require("../../stringify");
+
+var _string = require("../failsafe/string");
+
+var _options = require("../options");
+
+/* global atob, btoa, Buffer */
+var _default = {
+  identify: value => value instanceof Uint8Array,
+  // Buffer inherits from 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: (doc, node) => {
+    const src = (0, _string.resolveString)(doc, node);
+
+    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 {
+      const msg = 'This environment does not support reading binary tags; either Buffer or atob is required';
+      doc.errors.push(new _errors.YAMLReferenceError(node, msg));
+      return null;
+    }
+  },
+  options: _options.binaryOptions,
+  stringify: ({
+    comment,
+    type,
+    value
+  }, ctx, onComment, onChompKeep) => {
+    let src;
+
+    if (typeof Buffer === 'function') {
+      src = value instanceof Buffer ? value.toString('base64') : Buffer.from(value.buffer).toString('base64');
+    } else if (typeof btoa === 'function') {
+      let s = '';
+
+      for (let i = 0; i < value.length; ++i) s += String.fromCharCode(value[i]);
+
+      src = btoa(s);
+    } else {
+      throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
+    }
+
+    if (!type) type = _options.binaryOptions.defaultType;
+
+    if (type === _constants.Type.QUOTE_DOUBLE) {
+      value = src;
+    } else {
+      const {
+        lineWidth
+      } = _options.binaryOptions;
+      const n = Math.ceil(src.length / lineWidth);
+      const lines = new Array(n);
+
+      for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
+        lines[i] = src.substr(o, lineWidth);
+      }
+
+      value = lines.join(type === _constants.Type.BLOCK_LITERAL ? '\n' : ' ');
+    }
+
+    return (0, _stringify.stringifyString)({
+      comment,
+      type,
+      value
+    }, ctx, onComment, onChompKeep);
+  }
+};
+exports.default = _default;

data/spec/spec/dummy/node_modules/yaml/dist/tags/yaml-1.1/index.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Scalar = _interopRequireDefault(require("../../schema/Scalar"));
+
+var _stringify = require("../../stringify");
+
+var _failsafe = _interopRequireDefault(require("../failsafe"));
+
+var _options = require("../options");
+
+var _binary = _interopRequireDefault(require("./binary"));
+
+var _omap = _interopRequireDefault(require("./omap"));
+
+var _pairs = _interopRequireDefault(require("./pairs"));
+
+var _set = _interopRequireDefault(require("./set"));
+
+var _timestamp = require("./timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const boolStringify = ({
+  value
+}) => value ? _options.boolOptions.trueStr : _options.boolOptions.falseStr;
+
+var _default = _failsafe.default.concat([{
+  identify: value => value == null,
+  createNode: (schema, value, ctx) => ctx.wrapScalars ? new _Scalar.default(null) : null,
+  default: true,
+  tag: 'tag:yaml.org,2002:null',
+  test: /^(?:~|[Nn]ull|NULL)?$/,
+  resolve: () => null,
+  options: _options.nullOptions,
+  stringify: () => _options.nullOptions.nullStr
+}, {
+  identify: value => typeof value === 'boolean',
+  default: true,
+  tag: 'tag:yaml.org,2002:bool',
+  test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
+  resolve: () => true,
+  options: _options.boolOptions,
+  stringify: boolStringify
+}, {
+  identify: value => typeof value === 'boolean',
+  default: true,
+  tag: 'tag:yaml.org,2002:bool',
+  test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
+  resolve: () => false,
+  options: _options.boolOptions,
+  stringify: boolStringify
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'BIN',
+  test: /^0b([0-1_]+)$/,
+  resolve: (str, bin) => parseInt(bin.replace(/_/g, ''), 2),
+  stringify: ({
+    value
+  }) => '0b' + value.toString(2)
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'OCT',
+  test: /^[-+]?0([0-7_]+)$/,
+  resolve: (str, oct) => parseInt(oct.replace(/_/g, ''), 8),
+  stringify: ({
+    value
+  }) => (value < 0 ? '-0' : '0') + value.toString(8)
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  test: /^[-+]?[0-9][0-9_]*$/,
+  resolve: str => parseInt(str.replace(/_/g, ''), 10),
+  stringify: _stringify.stringifyNumber
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'HEX',
+  test: /^0x([0-9a-fA-F_]+)$/,
+  resolve: (str, hex) => parseInt(hex.replace(/_/g, ''), 16),
+  stringify: ({
+    value
+  }) => (value < 0 ? '-0x' : '0x') + value.toString(16)
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  test: /^(?:[-+]?\.inf|(\.nan))$/i,
+  resolve: (str, nan) => nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
+  stringify: _stringify.stringifyNumber
+}, {
+  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: ({
+    value
+  }) => Number(value).toExponential()
+}, {
+  identify: value => typeof value === 'number',
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/,
+
+  resolve(str, frac) {
+    const node = new _Scalar.default(parseFloat(str.replace(/_/g, '')));
+
+    if (frac) {
+      const f = frac.replace(/_/g, '');
+      if (f[f.length - 1] === '0') node.minFractionDigits = f.length;
+    }
+
+    return node;
+  },
+
+  stringify: _stringify.stringifyNumber
+}], _binary.default, _omap.default, _pairs.default, _set.default, _timestamp.intTime, _timestamp.floatTime, _timestamp.timestamp);
+
+exports.default = _default;