parser-ts
Version:
String parser combinators for TypeScript
205 lines (204 loc) • 7.02 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.notLower = exports.notUpper = exports.notLetter = exports.notAlphanum = exports.notSpace = exports.notDigit = exports.lower = exports.upper = exports.unicodeLetter = exports.letter = exports.alphanum = exports.space = exports.digit = exports.many1 = exports.many = exports.notOneOf = exports.oneOf = exports.notChar = exports.char = void 0;
/**
* @since 0.6.0
*/
var function_1 = require("fp-ts/lib/function");
var Predicate_1 = require("fp-ts/lib/Predicate");
var string_1 = require("fp-ts/lib/string");
var P = __importStar(require("./Parser"));
var maybe = P.maybe(string_1.Monoid);
// -------------------------------------------------------------------------------------
// constructors
// -------------------------------------------------------------------------------------
/**
* The `char` parser constructor returns a parser which matches only the
* specified single character
*
* @category constructors
* @since 0.6.0
*/
var char = function (c) {
return P.expected(P.sat(function (s) { return s === c; }), "\"".concat(c, "\""));
};
exports.char = char;
/**
* The `notChar` parser constructor makes a parser which will match any
* single character other than the one provided.
*
* @category constructors
* @since 0.6.0
*/
var notChar = function (c) {
return P.expected(P.sat(function (c1) { return c1 !== c; }), "anything but \"".concat(c, "\""));
};
exports.notChar = notChar;
var isOneOf = function (s, c) { return s.indexOf(c) !== -1; };
/**
* Matches any one character from the provided string.
*
* @category constructors
* @since 0.6.0
*/
var oneOf = function (s) {
return P.expected(P.sat(function (c) { return isOneOf(s, c); }), "One of \"".concat(s, "\""));
};
exports.oneOf = oneOf;
/**
* Matches a single character which isn't a character from the provided string.
*
* @category constructors
* @since 0.6.0
*/
var notOneOf = function (s) {
return P.expected(P.sat(function (c) { return !isOneOf(s, c); }), "Not one of ".concat(JSON.stringify(s)));
};
exports.notOneOf = notOneOf;
// -------------------------------------------------------------------------------------
// combinators
// -------------------------------------------------------------------------------------
/**
* Takes a `Parser<Char, string>` and matches it zero or more times, returning
* a `string` of what was matched.
*
* @category combinators
* @since 0.6.0
*/
var many = function (parser) { return maybe((0, exports.many1)(parser)); };
exports.many = many;
/**
* Takes a `Parser<Char, string>` and matches it one or more times, returning
* a `string` of what was matched.
*
* @category combinators
* @since 0.6.0
*/
var many1 = function (parser) {
return (0, function_1.pipe)(P.many1(parser), P.map(function (nea) { return nea.join(''); }));
};
exports.many1 = many1;
var isDigit = function (c) { return '0123456789'.indexOf(c) !== -1; };
/**
* Matches a single digit.
*
* @category combinators
* @since 0.6.0
*/
exports.digit = P.expected(P.sat(isDigit), 'a digit');
var spaceRe = /^\s$/;
var isSpace = function (c) { return spaceRe.test(c); };
/**
* Matches a single whitespace character.
*
* @category combinators
* @since 0.6.0
*/
exports.space = P.expected(P.sat(isSpace), 'a whitespace');
var isUnderscore = function (c) { return c === '_'; };
var isLetter = function (c) { return /[a-z]/.test(c.toLowerCase()); };
var isAlphanum = function (c) { return isLetter(c) || isDigit(c) || isUnderscore(c); };
/**
* Matches a single letter, digit or underscore character.
*
* @category combinators
* @since 0.6.0
*/
exports.alphanum = P.expected(P.sat(isAlphanum), 'a word character');
/**
* Matches a single ASCII letter.
*
* @since 0.6.0
*/
exports.letter = P.expected(P.sat(isLetter), 'a letter');
var isUnicodeLetter = function (c) { return c.toLowerCase() !== c.toUpperCase(); };
/**
* Matches a single Unicode letter.
* Works for scripts which have a notion of an upper case and lower case letters
* (Latin-based scripts, Greek, Russian etc).
*
* @category combinators
* @since 0.6.16
*/
exports.unicodeLetter = P.expected(P.sat(isUnicodeLetter), 'an unicode letter');
var isUpper = function (c) { return isLetter(c) && c === c.toUpperCase(); };
/**
* Matches a single upper case ASCII letter.
*
* @category combinators
* @since 0.6.0
*/
exports.upper = P.expected(P.sat(isUpper), 'an upper case letter');
var isLower = function (c) { return isLetter(c) && c === c.toLowerCase(); };
/**
* Matches a single lower case ASCII letter.
*
* @category combinators
* @since 0.6.0
*/
exports.lower = P.expected(P.sat(isLower), 'a lower case letter');
/**
* Matches a single character which isn't a digit.
*
* @category combinators
* @since 0.6.0
*/
exports.notDigit = P.expected(P.sat((0, Predicate_1.not)(isDigit)), 'a non-digit');
/**
* Matches a single character which isn't whitespace.
*
* @category combinators
* @since 0.6.0
*/
exports.notSpace = P.expected(P.sat((0, Predicate_1.not)(isSpace)), 'a non-whitespace character');
/**
* Matches a single character which isn't a letter, digit or underscore.
*
* @category combinators
* @since 0.6.0
*/
exports.notAlphanum = P.expected(P.sat((0, Predicate_1.not)(isAlphanum)), 'a non-word character');
/**
* Matches a single character which isn't an ASCII letter.
*
* @category combinators
* @since 0.6.0
*/
exports.notLetter = P.expected(P.sat((0, Predicate_1.not)(isLetter)), 'a non-letter character');
/**
* Matches a single character which isn't an upper case ASCII letter.
*
* @category combinators
* @since 0.6.0
*/
exports.notUpper = P.expected(P.sat((0, Predicate_1.not)(isUpper)), 'anything but an upper case letter');
/**
* Matches a single character which isn't a lower case ASCII letter.
*
* @category combinators
* @since 0.6.0
*/
exports.notLower = P.expected(P.sat((0, Predicate_1.not)(isLower)), 'anything but a lower case letter');