Constructor: OpenLayers.Format.Text
Create a new parser for TSV Text.

Parameters:
options - {Object} An optional object whose properties will be set on
this instance.
3922
function(options) {
        options = options || {};

        if(options.extractStyles !== false) {
            options.defaultStyle = {
                'externalGraphic': OpenLayers.Util.getImageLocation("marker.png"),
                'graphicWidth': 21,
                'graphicHeight': 25,
                'graphicXOffset': -10.5,
                'graphicYOffset': -12.5
            };
        }
        
        OpenLayers.Format.prototype.initialize.apply(this, [options]);
    }
65871
function Parser( options ) {

  if( !(this instanceof Parser) )
    return new Parser( options )

  Stream.Transform.call( this, options )

  this._readableState.objectMode = true
  this._buffer = ''

}
1253037
function Parser(options) {
    this.options = options || {};
    this.h = this.options.h || function (tagName, properties, value) {
        return value;
    };
    this.renderer = Object.assign(renderer, this.options.renderer || {});
}
1031910
function(options) {
        OpenLayers.Protocol.prototype.initialize.apply(this, [options]);
        if(!options.format) {
            this.format = new OpenLayers.Format.CSWGetRecords.v2_0_2(OpenLayers.Util.extend({
            }, this.formatOptions));
        }
    }
1356987
function parseOptions(type, options) {
    const ret = {
        indentChar: " ",
        indentSize: 2,
        startIndent: 1,
        switchCase: 0,
    }

    if (Number.isSafeInteger(type)) {
        ret.indentSize = type
    } else if (type === "tab") {
        ret.indentChar = "\t"
        ret.indentSize = 1
    }
    if (Number.isSafeInteger(options.switchCase)) {
        ret.switchCase = options.switchCase
    }
    if (Number.isSafeInteger(options.startIndent)) {
        ret.startIndent = options.startIndent
    }

    return ret
}
255102
function createTextNode (type, item) {
      var node = parser.createTextNode(type, item.surface_form)

      if (options && options.pos) {
        node.data = item
      }

      return node
    }
1365088
function(data, options) {
        if(typeof data == "string") {
            data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
        }

        // Loop throught the following node types in this order and
        // process the nodes found 
        var types = ["Link", "NetworkLink", "Style", "StyleMap", "Placemark"];
        for(var i=0, len=types.length; i<len; ++i) {
            var type = types[i];

            var nodes = this.getElementsByTagNameNS(data, "*", type);

            // skip to next type if no nodes are found
            if(nodes.length == 0) { 
                continue;
            }

            switch (type.toLowerCase()) {

                // Fetch external links 
                case "link":
                case "networklink":
                    this.parseLinks(nodes, options);
                    break;

                // parse style information
                case "style":
                    if (this.extractStyles) {
                        this.parseStyles(nodes, options);
                    }
                    break;
                case "stylemap":
                    if (this.extractStyles) {
                        this.parseStyleMaps(nodes, options);
                    }
                    break;

                // parse features
                case "placemark":
                    this.parseFeatures(nodes, options);
                    break;
            }
        }
        
        return this.features;
    }
819185
function parseOptions(options) {
  let separator
  let transformer

  if (2 === options.length) {
    [separator, transformer] = options
    if (defaultTransformers[transformer]) {
      transformer = defaultTransformers[transformer] /* Don't validate */
      validate({ separator })
    } else {
      validate({ separator, transformer })
    }
  } else if (1 === options.length) {
    const option = options[0]
    if (false === option || 'function' === typeof option) {
      transformer = option /* Don't validate */
    } else if (defaultTransformers[option]) {
      transformer = defaultTransformers[option] /* Don't validate */
    } else {
      separator = option
      validate({ separator })
    }
  }

  return { separator, transformer }
}
579901
def _parse_options():
    """"""

    parser = OptionParser(
        usage="%prog [options] input.md ...",
        description="Generates an HTML5 or PDF "
                    "slideshow from Markdown or other formats",
        epilog="Note: PDF export requires the `prince` program: "
               "http://princexml.com/",
        version="%prog " + __version__)

    parser.add_option(
        "-c", "--copy-theme",
        action="store_true",
        dest="copy_theme",
        help="Copy theme directory into current presentation source directory",
        default=False)

    parser.add_option(
        "-b", "--debug",
        action="store_true",
        dest="debug",
        help="Will display any exception trace to stdout",
        default=False)

    parser.add_option(
        "-d", "--destination",
        dest="destination_file",
        help="The path to the to the destination file: .html or "
             ".pdf extensions allowed (default: presentation.html)",
        metavar="FILE",
        default="presentation.html")

    parser.add_option(
        "-e", "--encoding",
        dest="encoding",
        help="The encoding of your files (defaults to utf8)",
        metavar="ENCODING",
        default="utf8")

    parser.add_option(
        "-i", "--embed",
        action="store_true",
        dest="embed",
        help="Embed stylesheet and javascript contents, "
             "base64-encoded images in presentation to make a "
             "standalone document",
        default=False)

    parser.add_option(
        "-l", "--linenos",
        type="choice",
        choices=generator.VALID_LINENOS,
        dest="linenos",
        help="How to output linenos in source code. Three options availables: "
        "no (no line numbers); "
        "inline (inside <pre> tag); "
        "table (lines numbers in another cell, copy-paste friendly)",
        default="inline",
    )

    parser.add_option(
        "-o", "--direct-output",
        action="store_true",
        dest="direct",
        help="Prints the generated HTML code to stdout; won't work with PDF "
             "export",
        default=False)

    parser.add_option(
        "-P", "--no-presenter-notes",
        action="store_false",
        dest="presenter_notes",
        help="Don't include presenter notes in the output",
        default=True)

    parser.add_option(
        "-q", "--quiet",
        action="store_false",
        dest="verbose",
        help="Won't write anything to stdout (silent mode)",
        default=False)

    parser.add_option(
        "-r", "--relative",
        action="store_true",
        dest="relative",
        help="Make your presentation asset links relative to current pwd; "
             "This may be useful if you intend to publish your html "
             "presentation online.",
        default=False,
    )

    parser.add_option(
        "-t", "--theme",
        dest="theme",
        help="A theme name, or path to a landlside theme directory",
        default='default')

    parser.add_option(
        "-v", "--verbose",
        action="store_true",
        dest="verbose",
        help="Write informational messages to stdout (enabled by default)",
        default=True)

    parser.add_option(
        "-x", "--extensions",
        dest="extensions",
        help="Comma-separated list of extensions for Markdown",
        default='',
    )

    parser.add_option(
        "-w", "--watch",
        action="store_true",
        dest="watch",
        help="Watch source directory for changes and regenerate slides",
        default=False
    )

    parser.add_option(
        "-m", "--math-output",
        action="store_true",
        dest="math_output",
        help="Enable mathematical output using MathJax",
        default=False
    )

    (options, args) = parser.parse_args()

    if not args:
        parser.print_help()
        sys.exit(1)

    return options, args[0]
973952
function Parser(options) {
  this.options = merge({}, {
    headers: {
      included: false,
      downcase: true,
      upcase: true
    },
    delimiter: 'tab',
    decimalSign: 'comma'
  }, options);
}
445602
function parse_style_json_object(text, options)
{
	// remove multiline comments
	text = text.replace(/\/\*([\s\S]*?)\*\//g, '')

	// ignore curly braces for now.
	// maybe support curly braces along with tabulation in future
	text = text.replace(/[\{\}]/g, '')

	const lines = text.split('\n')

	// helper class for dealing with tabulation
	const tabulator = new Tabulator(Tabulator.determine_tabulation(lines))

	// parse text into JSON object
	let style_json = parse_style_class(tabulator.extract_tabulation(lines), [])

	// expand CSS shorthand properties
	// (e.g. `margin: 1px` -> `margin-left: 1px; ...`)
	if (options.expand)
	{
		style_json = style_builder.build(style_json)
	}

	// expand "modifier" style classes
	// (which can override some of the expanded shorthand CSS properties)
	return expand_modifier_style_classes(style_json)
}
474334
def addCustomOptions(parser):
    
    parser.add_argument("--format", type=str, metavar="FORMAT", default="png",
                        choices=["png", "ps", "pdf", "X11"],
                        help="The output file format (png, ps, pdf, or X11 "
                             "formats are available). [default: %(default)s]")
    parser.add_argument("--title", type=str, metavar="STRING",
                        default="C2 in function of C1 - MDS",
                        help="The title of the MDS plot. [default: "
                             "%(default)s]")
    parser.add_argument("--xlabel", type=str, metavar="STRING", default="C1",
                        help="The label of the X axis. [default: %(default)s]")
    parser.add_argument("--ylabel", type=str, metavar="STRING", default="C2",
                        help="The label of the Y axis. [default: %(default)s]")
45855
function(opts, argv, error)
    {
        var parser = new Parser(opts, argv, error);
        return parser.parse();
    }
976194
function attacher (retext, options) {
  return function transformer (cst, file, next) {
    var textlint = new TextLintEngine(options)
    var result = textlint.executeOnText(toString(cst))

    if (result) {
      var messages = result[0].messages

      for (var index = 0; index < messages.length; index++) {
        var msg = messages[index]
        var msgText = '"' + msg.ruleId + '" ' + msg.message

        if (msg.severity === 1) {
          file.warn(msgText, {line: msg.line, column: msg.column})
        } else if (msg.severity === 2) {
          file.fail(msgText, {line: msg.line, column: msg.column})
        }
      }
    }

    next()
  }
}
760006
function configureESFormatter(options) {
	const ESFormatConfig = {
		root: true,
		allowShebang: true,
		indent: {value: '\t'},
		whiteSpace: {
			before: {
				IfStatementConditionalOpening: -1
			},
			after: {
				IfStatementConditionalClosing: -1,
				FunctionReservedWord: 1
			}
		},
		lineBreak: {after: {ClassDeclarationClosingBrace: 0}}
	}
	if (options.space > 0) {
		ESFormatConfig.indent.value = ' '.repeat(parseInt(options.space, 10))
	}

	console.debug(stripIndent`
		${clr.title}esFormatter Options${clr.title.out}:
	`)
	if (console.canWrite(5)) {
		console.pretty(ESFormatConfig, 2)
	}

	return () => esFormatter.rc(ESFormatConfig)
}
686899
function formatText(arr, text, props) {
  const formatArray = [];
  const localeCode = props.locale;
  for (let i = 0; i < arr.length; i += 1) {
    const el = arr[i];
    formatArray.push(isArray(el) ?
      formatText(el, locale[localeCode].surfix[colFlags[i]], props) :
      {
        text: addZero(el.text) +
              (isUndefined(text) ? locale[localeCode].surfix[colFlags[i]] : text),
        value: el.value,
      });
  }
  return formatArray;
}
450493
def parse_options(options)
      options = Shellwords.split(options) unless options.is_a?(Array)
      parser = Thor::Options.new(self.class.class_options)
      parser.parse(options)
    end