@aws-cdk/aws-imagebuilder-alpha 2.224.0-alpha.0

package/node_modules/yaml/index.d.ts

@@ -0,0 +1,372 @@
+import { CST } from './parse-cst'
+import {
+  AST,
+  Alias,
+  Collection,
+  Merge,
+  Node,
+  Scalar,
+  Schema,
+  YAMLMap,
+  YAMLSeq
+} from './types'
+import { Type, YAMLError, YAMLWarning } from './util'
+
+export { AST, CST }
+export { default as parseCST } from './parse-cst'
+
+/**
+ * `yaml` defines document-specific options in three places: as an argument of
+ * parse, create and stringify calls, in the values of `YAML.defaultOptions`,
+ * and in the version-dependent `YAML.Document.defaults` object. Values set in
+ * `YAML.defaultOptions` override version-dependent defaults, and argument
+ * options override both.
+ */
+export const defaultOptions: Options
+
+export interface Options extends Schema.Options {
+  /**
+   * Default prefix for anchors.
+   *
+   * Default: `'a'`, resulting in anchors `a1`, `a2`, etc.
+   */
+  anchorPrefix?: string
+  /**
+   * The number of spaces to use when indenting code.
+   *
+   * Default: `2`
+   */
+  indent?: number
+  /**
+   * Whether block sequences should be indented.
+   *
+   * Default: `true`
+   */
+  indentSeq?: boolean
+  /**
+   * Allow non-JSON JavaScript objects to remain in the `toJSON` output.
+   * Relevant with the YAML 1.1 `!!timestamp` and `!!binary` tags as well as BigInts.
+   *
+   * Default: `true`
+   */
+  keepBlobsInJSON?: boolean
+  /**
+   * Include references in the AST to each node's corresponding CST node.
+   *
+   * Default: `false`
+   */
+  keepCstNodes?: boolean
+  /**
+   * Store the original node type when parsing documents.
+   *
+   * Default: `true`
+   */
+  keepNodeTypes?: boolean
+  /**
+   * When outputting JS, use Map rather than Object to represent mappings.
+   *
+   * Default: `false`
+   */
+  mapAsMap?: boolean
+  /**
+   * Prevent exponential entity expansion attacks by limiting data aliasing count;
+   * set to `-1` to disable checks; `0` disallows all alias nodes.
+   *
+   * Default: `100`
+   */
+  maxAliasCount?: number
+  /**
+   * Include line position & node type directly in errors; drop their verbose source and context.
+   *
+   * Default: `false`
+   */
+  prettyErrors?: boolean
+  /**
+   * When stringifying, require keys to be scalars and to use implicit rather than explicit notation.
+   *
+   * Default: `false`
+   */
+  simpleKeys?: boolean
+  /**
+   * The YAML version used by documents without a `%YAML` directive.
+   *
+   * Default: `"1.2"`
+   */
+  version?: '1.0' | '1.1' | '1.2'
+}
+
+/**
+ * Some customization options are availabe to control the parsing and
+ * stringification of scalars. Note that these values are used by all documents.
+ */
+export const scalarOptions: {
+  binary: scalarOptions.Binary
+  bool: scalarOptions.Bool
+  int: scalarOptions.Int
+  null: scalarOptions.Null
+  str: scalarOptions.Str
+}
+export namespace scalarOptions {
+  interface Binary {
+    /**
+     * The type of string literal used to stringify `!!binary` values.
+     *
+     * Default: `'BLOCK_LITERAL'`
+     */
+    defaultType: Scalar.Type
+    /**
+     * Maximum line width for `!!binary`.
+     *
+     * Default: `76`
+     */
+    lineWidth: number
+  }
+
+  interface Bool {
+    /**
+     * String representation for `true`. With the core schema, use `'true' | 'True' | 'TRUE'`.
+     *
+     * Default: `'true'`
+     */
+    trueStr: string
+    /**
+     * String representation for `false`. With the core schema, use `'false' | 'False' | 'FALSE'`.
+     *
+     * Default: `'false'`
+     */
+    falseStr: string
+  }
+
+  interface Int {
+    /**
+     * Whether integers should be parsed into BigInt values.
+     *
+     * Default: `false`
+     */
+    asBigInt: boolean
+  }
+
+  interface Null {
+    /**
+     * String representation for `null`. With the core schema, use `'null' | 'Null' | 'NULL' | '~' | ''`.
+     *
+     * Default: `'null'`
+     */
+    nullStr: string
+  }
+
+  interface Str {
+    /**
+     * The default type of string literal used to stringify values
+     *
+     * Default: `'PLAIN'`
+     */
+    defaultType: Scalar.Type
+    doubleQuoted: {
+      /**
+       * Whether to restrict double-quoted strings to use JSON-compatible syntax.
+       *
+       * Default: `false`
+       */
+      jsonEncoding: boolean
+      /**
+       * Minimum length to use multiple lines to represent the value.
+       *
+       * Default: `40`
+       */
+      minMultiLineLength: number
+    }
+    fold: {
+      /**
+       * Maximum line width (set to `0` to disable folding).
+       *
+       * Default: `80`
+       */
+      lineWidth: number
+      /**
+       * Minimum width for highly-indented content.
+       *
+       * Default: `20`
+       */
+      minContentWidth: number
+    }
+  }
+}
+
+export class Document extends Collection {
+  cstNode?: CST.Document
+  constructor(options?: Options)
+  tag: never
+  directivesEndMarker?: boolean
+  type: Type.DOCUMENT
+  /**
+   * Anchors associated with the document's nodes;
+   * also provides alias & merge node creators.
+   */
+  anchors: Document.Anchors
+  /** The document contents. */
+  contents: any
+  /** Errors encountered during parsing. */
+  errors: YAMLError[]
+  /**
+   * The schema used with the document. Use `setSchema()` to change or
+   * initialise.
+   */
+  schema?: Schema
+  /**
+   * Array of prefixes; each will have a string `handle` that
+   * starts and ends with `!` and a string `prefix` that the handle will be replaced by.
+   */
+  tagPrefixes: Document.TagPrefix[]
+  /**
+   * The parsed version of the source document;
+   * if true-ish, stringified output will include a `%YAML` directive.
+   */
+  version?: string
+  /** Warnings encountered during parsing. */
+  warnings: YAMLWarning[]
+  /**
+   * List the tags used in the document that are not in the default
+   * `tag:yaml.org,2002:` namespace.
+   */
+  listNonDefaultTags(): string[]
+  /** Parse a CST into this document */
+  parse(cst: CST.Document): this
+  /**
+   * When a document is created with `new YAML.Document()`, the schema object is
+   * not set as it may be influenced by parsed directives; call this with no
+   * arguments to set it manually, or with arguments to change the schema used
+   * by the document.
+   **/
+  setSchema(
+    id?: Options['version'] | Schema.Name,
+    customTags?: (Schema.TagId | Schema.Tag)[]
+  ): void
+  /** Set `handle` as a shorthand string for the `prefix` tag namespace. */
+  setTagPrefix(handle: string, prefix: string): void
+  /**
+   * A plain JavaScript representation of the document `contents`.
+   *
+   * @param arg Used by `JSON.stringify` to indicate the array index or property
+   *   name. If its value is a `string` and the document `contents` has a scalar
+   *   value, the `keepBlobsInJSON` option has no effect.
+   * @param onAnchor If defined, called with the resolved `value` and reference
+   *   `count` for each anchor in the document.
+   * */
+  toJSON(arg?: string, onAnchor?: (value: any, count: number) => void): any
+  /** A YAML representation of the document. */
+  toString(): string
+}
+
+export namespace Document {
+  interface Parsed extends Document {
+    contents: Scalar | YAMLMap | YAMLSeq | null
+    /** The schema used with the document. */
+    schema: Schema
+  }
+
+  interface Anchors {
+    /**
+     * Create a new `Alias` node, adding the required anchor for `node`.
+     * If `name` is empty, a new anchor name will be generated.
+     */
+    createAlias(node: Node, name?: string): Alias
+    /**
+     * Create a new `Merge` node with the given source nodes.
+     * Non-`Alias` sources will be automatically wrapped.
+     */
+    createMergePair(...nodes: Node[]): Merge
+    /** The anchor name associated with `node`, if set. */
+    getName(node: Node): undefined | string
+    /** List of all defined anchor names. */
+    getNames(): string[]
+    /** The node associated with the anchor `name`, if set. */
+    getNode(name: string): undefined | Node
+    /**
+     * Find an available anchor name with the given `prefix` and a
+     * numerical suffix.
+     */
+    newName(prefix: string): string
+    /**
+     * Associate an anchor with `node`. If `name` is empty, a new name will be generated.
+     * To remove an anchor, use `setAnchor(null, name)`.
+     */
+    setAnchor(node: Node | null, name?: string): void | string
+  }
+
+  interface TagPrefix {
+    handle: string
+    prefix: string
+  }
+}
+
+/**
+ * Recursively turns objects into collections. Generic objects as well as `Map`
+ * and its descendants become mappings, while arrays and other iterable objects
+ * result in sequences.
+ *
+ * The primary purpose of this function is to enable attaching comments or other
+ * metadata to a value, or to otherwise exert more fine-grained control over the
+ * stringified output. To that end, you'll need to assign its return value to
+ * the `contents` of a Document (or somewhere within said contents), as the
+ * document's schema is required for YAML string output.
+ *
+ * @param wrapScalars If undefined or `true`, also wraps plain values in
+ *   `Scalar` objects; if `false` and `value` is not an object, it will be
+ *   returned directly.
+ * @param tag Use to specify the collection type, e.g. `"!!omap"`. Note that
+ *   this requires the corresponding tag to be available based on the default
+ *   options. To use a specific document's schema, use `doc.schema.createNode`.
+ */
+export function createNode(
+  value: any,
+  wrapScalars?: true,
+  tag?: string
+): YAMLMap | YAMLSeq | Scalar
+
+/**
+ * YAML.createNode recursively turns objects into Map and arrays to Seq collections.
+ * Its primary use is to enable attaching comments or other metadata to a value,
+ * or to otherwise exert more fine-grained control over the stringified output.
+ *
+ * Doesn't wrap plain values in Scalar objects.
+ */
+export function createNode(
+  value: any,
+  wrapScalars: false,
+  tag?: string
+): YAMLMap | YAMLSeq | string | number | boolean | null
+
+/**
+ * Parse an input string into a single YAML.Document.
+ */
+export function parseDocument(str: string, options?: Options): Document.Parsed
+
+/**
+ * Parse the input as a stream of YAML documents.
+ *
+ * Documents should be separated from each other by `...` or `---` marker lines.
+ */
+export function parseAllDocuments(
+  str: string,
+  options?: Options
+): Document.Parsed[]
+
+/**
+ * Parse an input string into JavaScript.
+ *
+ * Only supports input consisting of a single YAML document; for multi-document
+ * support you should use `YAML.parseAllDocuments`. May throw on error, and may
+ * log warnings using `console.warn`.
+ *
+ * @param str A string with YAML formatting.
+ * @returns The value will match the type of the root value of the parsed YAML
+ *   document, so Maps become objects, Sequences arrays, and scalars result in
+ *   nulls, booleans, numbers and strings.
+ */
+export function parse(str: string, options?: Options): any
+
+/**
+ * @returns Will always include \n as the last character, as is expected of YAML documents.
+ */
+export function stringify(value: any, options?: Options): string

package/node_modules/yaml/index.js

@@ -0,0 +1 @@
+module.exports = require('./dist').YAML

package/node_modules/yaml/map.js

@@ -0,0 +1,2 @@
+module.exports = require('./dist/types').YAMLMap
+require('./dist/legacy-exports').warnFileDeprecation(__filename)

package/node_modules/yaml/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "yaml",
+  "version": "1.10.2",
+  "license": "ISC",
+  "author": "Eemeli Aro <eemeli@gmail.com>",
+  "repository": "github:eemeli/yaml",
+  "description": "JavaScript parser and stringifier for YAML",
+  "keywords": [
+    "YAML",
+    "parser",
+    "stringifier"
+  ],
+  "homepage": "https://eemeli.org/yaml/v1/",
+  "files": [
+    "browser/",
+    "dist/",
+    "types/",
+    "*.d.ts",
+    "*.js",
+    "*.mjs",
+    "!*config.js"
+  ],
+  "type": "commonjs",
+  "main": "./index.js",
+  "browser": {
+    "./index.js": "./browser/index.js",
+    "./map.js": "./browser/map.js",
+    "./pair.js": "./browser/pair.js",
+    "./parse-cst.js": "./browser/parse-cst.js",
+    "./scalar.js": "./browser/scalar.js",
+    "./schema.js": "./browser/schema.js",
+    "./seq.js": "./browser/seq.js",
+    "./types.js": "./browser/types.js",
+    "./types.mjs": "./browser/types.js",
+    "./types/binary.js": "./browser/types/binary.js",
+    "./types/omap.js": "./browser/types/omap.js",
+    "./types/pairs.js": "./browser/types/pairs.js",
+    "./types/set.js": "./browser/types/set.js",
+    "./types/timestamp.js": "./browser/types/timestamp.js",
+    "./util.js": "./browser/util.js",
+    "./util.mjs": "./browser/util.js"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./parse-cst": "./parse-cst.js",
+    "./types": [
+      {
+        "import": "./types.mjs"
+      },
+      "./types.js"
+    ],
+    "./util": [
+      {
+        "import": "./util.mjs"
+      },
+      "./util.js"
+    ],
+    "./": "./"
+  },
+  "scripts": {
+    "build": "npm run build:node && npm run build:browser",
+    "build:browser": "rollup -c rollup.browser-config.js",
+    "build:node": "rollup -c rollup.node-config.js",
+    "clean": "git clean -fdxe node_modules",
+    "lint": "eslint src/",
+    "prettier": "prettier --write .",
+    "start": "cross-env TRACE_LEVEL=log npm run build:node && node -i -e 'YAML=require(\".\")'",
+    "test": "jest",
+    "test:browsers": "cd playground && npm test",
+    "test:dist": "npm run build:node && jest",
+    "test:types": "tsc --lib ES2017 --noEmit tests/typings.ts",
+    "docs:install": "cd docs-slate && bundle install",
+    "docs:deploy": "cd docs-slate && ./deploy.sh",
+    "docs": "cd docs-slate && bundle exec middleman server",
+    "preversion": "npm test && npm run build",
+    "prepublishOnly": "npm run clean && npm test && npm run build"
+  },
+  "browserslist": "> 0.5%, not dead",
+  "prettier": {
+    "arrowParens": "avoid",
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.10",
+    "@babel/plugin-proposal-class-properties": "^7.12.1",
+    "@babel/preset-env": "^7.12.11",
+    "@rollup/plugin-babel": "^5.2.3",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
+    "babel-plugin-trace": "^1.1.0",
+    "common-tags": "^1.8.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^7.19.0",
+    "eslint-config-prettier": "^7.2.0",
+    "fast-check": "^2.12.0",
+    "jest": "^26.6.3",
+    "prettier": "^2.2.1",
+    "rollup": "^2.38.2",
+    "typescript": "^4.1.3"
+  },
+  "engines": {
+    "node": ">= 6"
+  }
+}

package/node_modules/yaml/pair.js

@@ -0,0 +1,2 @@
+module.exports = require('./dist/types').Pair
+require('./dist/legacy-exports').warnFileDeprecation(__filename)

package/node_modules/yaml/parse-cst.d.ts

@@ -0,0 +1,191 @@
+import { Type, YAMLSyntaxError } from './util'
+
+export default function parseCST(str: string): ParsedCST
+
+export interface ParsedCST extends Array<CST.Document> {
+  setOrigRanges(): boolean
+}
+
+export namespace CST {
+  interface Range {
+    start: number
+    end: number
+    origStart?: number
+    origEnd?: number
+    isEmpty(): boolean
+  }
+
+  interface ParseContext {
+    /** Node starts at beginning of line */
+    atLineStart: boolean
+    /** true if currently in a collection context */
+    inCollection: boolean
+    /** true if currently in a flow context */
+    inFlow: boolean
+    /** Current level of indentation */
+    indent: number
+    /** Start of the current line */
+    lineStart: number
+    /** The parent of the node */
+    parent: Node
+    /** Source of the YAML document */
+    src: string
+  }
+
+  interface Node {
+    context: ParseContext | null
+    /** if not null, indicates a parser failure */
+    error: YAMLSyntaxError | null
+    /** span of context.src parsed into this node */
+    range: Range | null
+    valueRange: Range | null
+    /** anchors, tags and comments */
+    props: Range[]
+    /** specific node type */
+    type: Type
+    /** if non-null, overrides source value */
+    value: string | null
+
+    readonly anchor: string | null
+    readonly comment: string | null
+    readonly hasComment: boolean
+    readonly hasProps: boolean
+    readonly jsonLike: boolean
+    readonly rangeAsLinePos: null | {
+      start: { line: number; col: number }
+      end?: { line: number; col: number }
+    }
+    readonly rawValue: string | null
+    readonly tag:
+      | null
+      | { verbatim: string }
+      | { handle: string; suffix: string }
+    readonly valueRangeContainsNewline: boolean
+  }
+
+  interface Alias extends Node {
+    type: Type.ALIAS
+    /** contain the anchor without the * prefix */
+    readonly rawValue: string
+  }
+
+  type Scalar = BlockValue | PlainValue | QuoteValue
+
+  interface BlockValue extends Node {
+    type: Type.BLOCK_FOLDED | Type.BLOCK_LITERAL
+    chomping: 'CLIP' | 'KEEP' | 'STRIP'
+    blockIndent: number | null
+    header: Range
+    readonly strValue: string | null
+  }
+
+  interface BlockFolded extends BlockValue {
+    type: Type.BLOCK_FOLDED
+  }
+
+  interface BlockLiteral extends BlockValue {
+    type: Type.BLOCK_LITERAL
+  }
+
+  interface PlainValue extends Node {
+    type: Type.PLAIN
+    readonly strValue: string | null
+  }
+
+  interface QuoteValue extends Node {
+    type: Type.QUOTE_DOUBLE | Type.QUOTE_SINGLE
+    readonly strValue:
+      | null
+      | string
+      | { str: string; errors: YAMLSyntaxError[] }
+  }
+
+  interface QuoteDouble extends QuoteValue {
+    type: Type.QUOTE_DOUBLE
+  }
+
+  interface QuoteSingle extends QuoteValue {
+    type: Type.QUOTE_SINGLE
+  }
+
+  interface Comment extends Node {
+    type: Type.COMMENT
+    readonly anchor: null
+    readonly comment: string
+    readonly rawValue: null
+    readonly tag: null
+  }
+
+  interface BlankLine extends Node {
+    type: Type.BLANK_LINE
+  }
+
+  interface MapItem extends Node {
+    type: Type.MAP_KEY | Type.MAP_VALUE
+    node: ContentNode | null
+  }
+
+  interface MapKey extends MapItem {
+    type: Type.MAP_KEY
+  }
+
+  interface MapValue extends MapItem {
+    type: Type.MAP_VALUE
+  }
+
+  interface Map extends Node {
+    type: Type.MAP
+    /** implicit keys are not wrapped */
+    items: Array<BlankLine | Comment | Alias | Scalar | MapItem>
+  }
+
+  interface SeqItem extends Node {
+    type: Type.SEQ_ITEM
+    node: ContentNode | null
+  }
+
+  interface Seq extends Node {
+    type: Type.SEQ
+    items: Array<BlankLine | Comment | SeqItem>
+  }
+
+  interface FlowChar {
+    char: '{' | '}' | '[' | ']' | ',' | '?' | ':'
+    offset: number
+    origOffset?: number
+  }
+
+  interface FlowCollection extends Node {
+    type: Type.FLOW_MAP | Type.FLOW_SEQ
+    items: Array<
+      FlowChar | BlankLine | Comment | Alias | Scalar | FlowCollection
+    >
+  }
+
+  interface FlowMap extends FlowCollection {
+    type: Type.FLOW_MAP
+  }
+
+  interface FlowSeq extends FlowCollection {
+    type: Type.FLOW_SEQ
+  }
+
+  type ContentNode = Alias | Scalar | Map | Seq | FlowCollection
+
+  interface Directive extends Node {
+    type: Type.DIRECTIVE
+    name: string
+    readonly anchor: null
+    readonly parameters: string[]
+    readonly tag: null
+  }
+
+  interface Document extends Node {
+    type: Type.DOCUMENT
+    directives: Array<BlankLine | Comment | Directive>
+    contents: Array<BlankLine | Comment | ContentNode>
+    readonly anchor: null
+    readonly comment: null
+    readonly tag: null
+  }
+}

package/node_modules/yaml/parse-cst.js

@@ -0,0 +1 @@
+module.exports = require('./dist/parse-cst').parse

package/node_modules/yaml/scalar.js

@@ -0,0 +1,2 @@
+module.exports = require('./dist/types').Scalar
+require('./dist/legacy-exports').warnFileDeprecation(__filename)

package/node_modules/yaml/schema.js

@@ -0,0 +1,9 @@
+const types = require('./dist/types')
+const util = require('./dist/util')
+
+module.exports = types.Schema
+module.exports.nullOptions = types.nullOptions
+module.exports.strOptions = types.strOptions
+module.exports.stringify = util.stringifyString
+
+require('./dist/legacy-exports').warnFileDeprecation(__filename)

package/node_modules/yaml/seq.js

@@ -0,0 +1,2 @@
+module.exports = require('./dist/types').YAMLSeq
+require('./dist/legacy-exports').warnFileDeprecation(__filename)