(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.SyndicateCompiler = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o * @license MIT */ /* eslint-disable no-proto */ 'use strict' var base64 = require('base64-js') var ieee754 = require('ieee754') var isArray = require('isarray') exports.Buffer = Buffer exports.SlowBuffer = SlowBuffer exports.INSPECT_MAX_BYTES = 50 Buffer.poolSize = 8192 // not used by this implementation var rootParent = {} /** * If `Buffer.TYPED_ARRAY_SUPPORT`: * === true Use Uint8Array implementation (fastest) * === false Use Object implementation (most compatible, even IE6) * * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, * Opera 11.6+, iOS 4.2+. * * Due to various browser bugs, sometimes the Object implementation will be used even * when the browser supports typed arrays. * * Note: * * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. * * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. * * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of * incorrect length in some situations. * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they * get the Object implementation, which is slower but behaves correctly. */ Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport() function typedArraySupport () { try { var arr = new Uint8Array(1) arr.foo = function () { return 42 } return arr.foo() === 42 && // typed array instances can be augmented typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` } catch (e) { return false } } function kMaxLength () { return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff } /** * The Buffer constructor returns instances of `Uint8Array` that have their * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of * `Uint8Array`, so the returned instances will have all the node `Buffer` methods * and the `Uint8Array` methods. Square bracket notation works as expected -- it * returns a single octet. * * The `Uint8Array` prototype remains unmodified. */ function Buffer (arg) { if (!(this instanceof Buffer)) { // Avoid going through an ArgumentsAdaptorTrampoline in the common case. if (arguments.length > 1) return new Buffer(arg, arguments[1]) return new Buffer(arg) } if (!Buffer.TYPED_ARRAY_SUPPORT) { this.length = 0 this.parent = undefined } // Common case. if (typeof arg === 'number') { return fromNumber(this, arg) } // Slightly less common case. if (typeof arg === 'string') { return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8') } // Unusual. return fromObject(this, arg) } // TODO: Legacy, not needed anymore. Remove in next major version. Buffer._augment = function (arr) { arr.__proto__ = Buffer.prototype return arr } function fromNumber (that, length) { that = allocate(that, length < 0 ? 0 : checked(length) | 0) if (!Buffer.TYPED_ARRAY_SUPPORT) { for (var i = 0; i < length; i++) { that[i] = 0 } } return that } function fromString (that, string, encoding) { if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8' // Assumption: byteLength() return value is always < kMaxLength. var length = byteLength(string, encoding) | 0 that = allocate(that, length) that.write(string, encoding) return that } function fromObject (that, object) { if (Buffer.isBuffer(object)) return fromBuffer(that, object) if (isArray(object)) return fromArray(that, object) if (object == null) { throw new TypeError('must start with number, buffer, array or string') } if (typeof ArrayBuffer !== 'undefined') { if (object.buffer instanceof ArrayBuffer) { return fromTypedArray(that, object) } if (object instanceof ArrayBuffer) { return fromArrayBuffer(that, object) } } if (object.length) return fromArrayLike(that, object) return fromJsonObject(that, object) } function fromBuffer (that, buffer) { var length = checked(buffer.length) | 0 that = allocate(that, length) buffer.copy(that, 0, 0, length) return that } function fromArray (that, array) { var length = checked(array.length) | 0 that = allocate(that, length) for (var i = 0; i < length; i += 1) { that[i] = array[i] & 255 } return that } // Duplicate of fromArray() to keep fromArray() monomorphic. function fromTypedArray (that, array) { var length = checked(array.length) | 0 that = allocate(that, length) // Truncating the elements is probably not what people expect from typed // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior // of the old Buffer constructor. for (var i = 0; i < length; i += 1) { that[i] = array[i] & 255 } return that } function fromArrayBuffer (that, array) { array.byteLength // this throws if `array` is not a valid ArrayBuffer if (Buffer.TYPED_ARRAY_SUPPORT) { // Return an augmented `Uint8Array` instance, for best performance that = new Uint8Array(array) that.__proto__ = Buffer.prototype } else { // Fallback: Return an object instance of the Buffer class that = fromTypedArray(that, new Uint8Array(array)) } return that } function fromArrayLike (that, array) { var length = checked(array.length) | 0 that = allocate(that, length) for (var i = 0; i < length; i += 1) { that[i] = array[i] & 255 } return that } // Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object. // Returns a zero-length buffer for inputs that don't conform to the spec. function fromJsonObject (that, object) { var array var length = 0 if (object.type === 'Buffer' && isArray(object.data)) { array = object.data length = checked(array.length) | 0 } that = allocate(that, length) for (var i = 0; i < length; i += 1) { that[i] = array[i] & 255 } return that } if (Buffer.TYPED_ARRAY_SUPPORT) { Buffer.prototype.__proto__ = Uint8Array.prototype Buffer.__proto__ = Uint8Array } else { // pre-set for values that may exist in the future Buffer.prototype.length = undefined Buffer.prototype.parent = undefined } function allocate (that, length) { if (Buffer.TYPED_ARRAY_SUPPORT) { // Return an augmented `Uint8Array` instance, for best performance that = new Uint8Array(length) that.__proto__ = Buffer.prototype } else { // Fallback: Return an object instance of the Buffer class that.length = length } var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1 if (fromPool) that.parent = rootParent return that } function checked (length) { // Note: cannot use `length < kMaxLength` here because that fails when // length is NaN (which is otherwise coerced to zero.) if (length >= kMaxLength()) { throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes') } return length | 0 } function SlowBuffer (subject, encoding) { if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) var buf = new Buffer(subject, encoding) delete buf.parent return buf } Buffer.isBuffer = function isBuffer (b) { return !!(b != null && b._isBuffer) } Buffer.compare = function compare (a, b) { if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { throw new TypeError('Arguments must be Buffers') } if (a === b) return 0 var x = a.length var y = b.length var i = 0 var len = Math.min(x, y) while (i < len) { if (a[i] !== b[i]) break ++i } if (i !== len) { x = a[i] y = b[i] } if (x < y) return -1 if (y < x) return 1 return 0 } Buffer.isEncoding = function isEncoding (encoding) { switch (String(encoding).toLowerCase()) { case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'raw': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return true default: return false } } Buffer.concat = function concat (list, length) { if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') if (list.length === 0) { return new Buffer(0) } var i if (length === undefined) { length = 0 for (i = 0; i < list.length; i++) { length += list[i].length } } var buf = new Buffer(length) var pos = 0 for (i = 0; i < list.length; i++) { var item = list[i] item.copy(buf, pos) pos += item.length } return buf } function byteLength (string, encoding) { if (typeof string !== 'string') string = '' + string var len = string.length if (len === 0) return 0 // Use a for loop to avoid recursion var loweredCase = false for (;;) { switch (encoding) { case 'ascii': case 'binary': // Deprecated case 'raw': case 'raws': return len case 'utf8': case 'utf-8': return utf8ToBytes(string).length case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return len * 2 case 'hex': return len >>> 1 case 'base64': return base64ToBytes(string).length default: if (loweredCase) return utf8ToBytes(string).length // assume utf8 encoding = ('' + encoding).toLowerCase() loweredCase = true } } } Buffer.byteLength = byteLength function slowToString (encoding, start, end) { var loweredCase = false start = start | 0 end = end === undefined || end === Infinity ? this.length : end | 0 if (!encoding) encoding = 'utf8' if (start < 0) start = 0 if (end > this.length) end = this.length if (end <= start) return '' while (true) { switch (encoding) { case 'hex': return hexSlice(this, start, end) case 'utf8': case 'utf-8': return utf8Slice(this, start, end) case 'ascii': return asciiSlice(this, start, end) case 'binary': return binarySlice(this, start, end) case 'base64': return base64Slice(this, start, end) case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return utf16leSlice(this, start, end) default: if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) encoding = (encoding + '').toLowerCase() loweredCase = true } } } // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect // Buffer instances. Buffer.prototype._isBuffer = true Buffer.prototype.toString = function toString () { var length = this.length | 0 if (length === 0) return '' if (arguments.length === 0) return utf8Slice(this, 0, length) return slowToString.apply(this, arguments) } Buffer.prototype.equals = function equals (b) { if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') if (this === b) return true return Buffer.compare(this, b) === 0 } Buffer.prototype.inspect = function inspect () { var str = '' var max = exports.INSPECT_MAX_BYTES if (this.length > 0) { str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') if (this.length > max) str += ' ... ' } return '' } Buffer.prototype.compare = function compare (b) { if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') if (this === b) return 0 return Buffer.compare(this, b) } Buffer.prototype.indexOf = function indexOf (val, byteOffset) { if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff else if (byteOffset < -0x80000000) byteOffset = -0x80000000 byteOffset >>= 0 if (this.length === 0) return -1 if (byteOffset >= this.length) return -1 // Negative offsets start from the end of the buffer if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) if (typeof val === 'string') { if (val.length === 0) return -1 // special case: looking for empty string always fails return String.prototype.indexOf.call(this, val, byteOffset) } if (Buffer.isBuffer(val)) { return arrayIndexOf(this, val, byteOffset) } if (typeof val === 'number') { if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { return Uint8Array.prototype.indexOf.call(this, val, byteOffset) } return arrayIndexOf(this, [ val ], byteOffset) } function arrayIndexOf (arr, val, byteOffset) { var foundIndex = -1 for (var i = 0; byteOffset + i < arr.length; i++) { if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { if (foundIndex === -1) foundIndex = i if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex } else { foundIndex = -1 } } return -1 } throw new TypeError('val must be string, number or Buffer') } function hexWrite (buf, string, offset, length) { offset = Number(offset) || 0 var remaining = buf.length - offset if (!length) { length = remaining } else { length = Number(length) if (length > remaining) { length = remaining } } // must be an even number of digits var strLen = string.length if (strLen % 2 !== 0) throw new Error('Invalid hex string') if (length > strLen / 2) { length = strLen / 2 } for (var i = 0; i < length; i++) { var parsed = parseInt(string.substr(i * 2, 2), 16) if (isNaN(parsed)) throw new Error('Invalid hex string') buf[offset + i] = parsed } return i } function utf8Write (buf, string, offset, length) { return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) } function asciiWrite (buf, string, offset, length) { return blitBuffer(asciiToBytes(string), buf, offset, length) } function binaryWrite (buf, string, offset, length) { return asciiWrite(buf, string, offset, length) } function base64Write (buf, string, offset, length) { return blitBuffer(base64ToBytes(string), buf, offset, length) } function ucs2Write (buf, string, offset, length) { return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) } Buffer.prototype.write = function write (string, offset, length, encoding) { // Buffer#write(string) if (offset === undefined) { encoding = 'utf8' length = this.length offset = 0 // Buffer#write(string, encoding) } else if (length === undefined && typeof offset === 'string') { encoding = offset length = this.length offset = 0 // Buffer#write(string, offset[, length][, encoding]) } else if (isFinite(offset)) { offset = offset | 0 if (isFinite(length)) { length = length | 0 if (encoding === undefined) encoding = 'utf8' } else { encoding = length length = undefined } // legacy write(string, encoding, offset, length) - remove in v0.13 } else { var swap = encoding encoding = offset offset = length | 0 length = swap } var remaining = this.length - offset if (length === undefined || length > remaining) length = remaining if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { throw new RangeError('attempt to write outside buffer bounds') } if (!encoding) encoding = 'utf8' var loweredCase = false for (;;) { switch (encoding) { case 'hex': return hexWrite(this, string, offset, length) case 'utf8': case 'utf-8': return utf8Write(this, string, offset, length) case 'ascii': return asciiWrite(this, string, offset, length) case 'binary': return binaryWrite(this, string, offset, length) case 'base64': // Warning: maxLength not taken into account in base64Write return base64Write(this, string, offset, length) case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': return ucs2Write(this, string, offset, length) default: if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) encoding = ('' + encoding).toLowerCase() loweredCase = true } } } Buffer.prototype.toJSON = function toJSON () { return { type: 'Buffer', data: Array.prototype.slice.call(this._arr || this, 0) } } function base64Slice (buf, start, end) { if (start === 0 && end === buf.length) { return base64.fromByteArray(buf) } else { return base64.fromByteArray(buf.slice(start, end)) } } function utf8Slice (buf, start, end) { end = Math.min(buf.length, end) var res = [] var i = start while (i < end) { var firstByte = buf[i] var codePoint = null var bytesPerSequence = (firstByte > 0xEF) ? 4 : (firstByte > 0xDF) ? 3 : (firstByte > 0xBF) ? 2 : 1 if (i + bytesPerSequence <= end) { var secondByte, thirdByte, fourthByte, tempCodePoint switch (bytesPerSequence) { case 1: if (firstByte < 0x80) { codePoint = firstByte } break case 2: secondByte = buf[i + 1] if ((secondByte & 0xC0) === 0x80) { tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) if (tempCodePoint > 0x7F) { codePoint = tempCodePoint } } break case 3: secondByte = buf[i + 1] thirdByte = buf[i + 2] if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { codePoint = tempCodePoint } } break case 4: secondByte = buf[i + 1] thirdByte = buf[i + 2] fourthByte = buf[i + 3] if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { codePoint = tempCodePoint } } } } if (codePoint === null) { // we did not generate a valid codePoint so insert a // replacement char (U+FFFD) and advance only 1 byte codePoint = 0xFFFD bytesPerSequence = 1 } else if (codePoint > 0xFFFF) { // encode to utf16 (surrogate pair dance) codePoint -= 0x10000 res.push(codePoint >>> 10 & 0x3FF | 0xD800) codePoint = 0xDC00 | codePoint & 0x3FF } res.push(codePoint) i += bytesPerSequence } return decodeCodePointsArray(res) } // Based on http://stackoverflow.com/a/22747272/680742, the browser with // the lowest limit is Chrome, with 0x10000 args. // We go 1 magnitude less, for safety var MAX_ARGUMENTS_LENGTH = 0x1000 function decodeCodePointsArray (codePoints) { var len = codePoints.length if (len <= MAX_ARGUMENTS_LENGTH) { return String.fromCharCode.apply(String, codePoints) // avoid extra slice() } // Decode in chunks to avoid "call stack size exceeded". var res = '' var i = 0 while (i < len) { res += String.fromCharCode.apply( String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) ) } return res } function asciiSlice (buf, start, end) { var ret = '' end = Math.min(buf.length, end) for (var i = start; i < end; i++) { ret += String.fromCharCode(buf[i] & 0x7F) } return ret } function binarySlice (buf, start, end) { var ret = '' end = Math.min(buf.length, end) for (var i = start; i < end; i++) { ret += String.fromCharCode(buf[i]) } return ret } function hexSlice (buf, start, end) { var len = buf.length if (!start || start < 0) start = 0 if (!end || end < 0 || end > len) end = len var out = '' for (var i = start; i < end; i++) { out += toHex(buf[i]) } return out } function utf16leSlice (buf, start, end) { var bytes = buf.slice(start, end) var res = '' for (var i = 0; i < bytes.length; i += 2) { res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) } return res } Buffer.prototype.slice = function slice (start, end) { var len = this.length start = ~~start end = end === undefined ? len : ~~end if (start < 0) { start += len if (start < 0) start = 0 } else if (start > len) { start = len } if (end < 0) { end += len if (end < 0) end = 0 } else if (end > len) { end = len } if (end < start) end = start var newBuf if (Buffer.TYPED_ARRAY_SUPPORT) { newBuf = this.subarray(start, end) newBuf.__proto__ = Buffer.prototype } else { var sliceLen = end - start newBuf = new Buffer(sliceLen, undefined) for (var i = 0; i < sliceLen; i++) { newBuf[i] = this[i + start] } } if (newBuf.length) newBuf.parent = this.parent || this return newBuf } /* * Need to make sure that buffer isn't trying to write out of bounds. */ function checkOffset (offset, ext, length) { if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') } Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { offset = offset | 0 byteLength = byteLength | 0 if (!noAssert) checkOffset(offset, byteLength, this.length) var val = this[offset] var mul = 1 var i = 0 while (++i < byteLength && (mul *= 0x100)) { val += this[offset + i] * mul } return val } Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { offset = offset | 0 byteLength = byteLength | 0 if (!noAssert) { checkOffset(offset, byteLength, this.length) } var val = this[offset + --byteLength] var mul = 1 while (byteLength > 0 && (mul *= 0x100)) { val += this[offset + --byteLength] * mul } return val } Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { if (!noAssert) checkOffset(offset, 1, this.length) return this[offset] } Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { if (!noAssert) checkOffset(offset, 2, this.length) return this[offset] | (this[offset + 1] << 8) } Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { if (!noAssert) checkOffset(offset, 2, this.length) return (this[offset] << 8) | this[offset + 1] } Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { if (!noAssert) checkOffset(offset, 4, this.length) return ((this[offset]) | (this[offset + 1] << 8) | (this[offset + 2] << 16)) + (this[offset + 3] * 0x1000000) } Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { if (!noAssert) checkOffset(offset, 4, this.length) return (this[offset] * 0x1000000) + ((this[offset + 1] << 16) | (this[offset + 2] << 8) | this[offset + 3]) } Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { offset = offset | 0 byteLength = byteLength | 0 if (!noAssert) checkOffset(offset, byteLength, this.length) var val = this[offset] var mul = 1 var i = 0 while (++i < byteLength && (mul *= 0x100)) { val += this[offset + i] * mul } mul *= 0x80 if (val >= mul) val -= Math.pow(2, 8 * byteLength) return val } Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { offset = offset | 0 byteLength = byteLength | 0 if (!noAssert) checkOffset(offset, byteLength, this.length) var i = byteLength var mul = 1 var val = this[offset + --i] while (i > 0 && (mul *= 0x100)) { val += this[offset + --i] * mul } mul *= 0x80 if (val >= mul) val -= Math.pow(2, 8 * byteLength) return val } Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { if (!noAssert) checkOffset(offset, 1, this.length) if (!(this[offset] & 0x80)) return (this[offset]) return ((0xff - this[offset] + 1) * -1) } Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { if (!noAssert) checkOffset(offset, 2, this.length) var val = this[offset] | (this[offset + 1] << 8) return (val & 0x8000) ? val | 0xFFFF0000 : val } Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { if (!noAssert) checkOffset(offset, 2, this.length) var val = this[offset + 1] | (this[offset] << 8) return (val & 0x8000) ? val | 0xFFFF0000 : val } Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { if (!noAssert) checkOffset(offset, 4, this.length) return (this[offset]) | (this[offset + 1] << 8) | (this[offset + 2] << 16) | (this[offset + 3] << 24) } Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { if (!noAssert) checkOffset(offset, 4, this.length) return (this[offset] << 24) | (this[offset + 1] << 16) | (this[offset + 2] << 8) | (this[offset + 3]) } Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { if (!noAssert) checkOffset(offset, 4, this.length) return ieee754.read(this, offset, true, 23, 4) } Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { if (!noAssert) checkOffset(offset, 4, this.length) return ieee754.read(this, offset, false, 23, 4) } Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { if (!noAssert) checkOffset(offset, 8, this.length) return ieee754.read(this, offset, true, 52, 8) } Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { if (!noAssert) checkOffset(offset, 8, this.length) return ieee754.read(this, offset, false, 52, 8) } function checkInt (buf, value, offset, ext, max, min) { if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance') if (value > max || value < min) throw new RangeError('value is out of bounds') if (offset + ext > buf.length) throw new RangeError('index out of range') } Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { value = +value offset = offset | 0 byteLength = byteLength | 0 if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) var mul = 1 var i = 0 this[offset] = value & 0xFF while (++i < byteLength && (mul *= 0x100)) { this[offset + i] = (value / mul) & 0xFF } return offset + byteLength } Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { value = +value offset = offset | 0 byteLength = byteLength | 0 if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) var i = byteLength - 1 var mul = 1 this[offset + i] = value & 0xFF while (--i >= 0 && (mul *= 0x100)) { this[offset + i] = (value / mul) & 0xFF } return offset + byteLength } Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) this[offset] = (value & 0xff) return offset + 1 } function objectWriteUInt16 (buf, value, offset, littleEndian) { if (value < 0) value = 0xffff + value + 1 for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> (littleEndian ? i : 1 - i) * 8 } } Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value & 0xff) this[offset + 1] = (value >>> 8) } else { objectWriteUInt16(this, value, offset, true) } return offset + 2 } Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value >>> 8) this[offset + 1] = (value & 0xff) } else { objectWriteUInt16(this, value, offset, false) } return offset + 2 } function objectWriteUInt32 (buf, value, offset, littleEndian) { if (value < 0) value = 0xffffffff + value + 1 for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff } } Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset + 3] = (value >>> 24) this[offset + 2] = (value >>> 16) this[offset + 1] = (value >>> 8) this[offset] = (value & 0xff) } else { objectWriteUInt32(this, value, offset, true) } return offset + 4 } Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value >>> 24) this[offset + 1] = (value >>> 16) this[offset + 2] = (value >>> 8) this[offset + 3] = (value & 0xff) } else { objectWriteUInt32(this, value, offset, false) } return offset + 4 } Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { value = +value offset = offset | 0 if (!noAssert) { var limit = Math.pow(2, 8 * byteLength - 1) checkInt(this, value, offset, byteLength, limit - 1, -limit) } var i = 0 var mul = 1 var sub = value < 0 ? 1 : 0 this[offset] = value & 0xFF while (++i < byteLength && (mul *= 0x100)) { this[offset + i] = ((value / mul) >> 0) - sub & 0xFF } return offset + byteLength } Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { value = +value offset = offset | 0 if (!noAssert) { var limit = Math.pow(2, 8 * byteLength - 1) checkInt(this, value, offset, byteLength, limit - 1, -limit) } var i = byteLength - 1 var mul = 1 var sub = value < 0 ? 1 : 0 this[offset + i] = value & 0xFF while (--i >= 0 && (mul *= 0x100)) { this[offset + i] = ((value / mul) >> 0) - sub & 0xFF } return offset + byteLength } Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) if (value < 0) value = 0xff + value + 1 this[offset] = (value & 0xff) return offset + 1 } Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value & 0xff) this[offset + 1] = (value >>> 8) } else { objectWriteUInt16(this, value, offset, true) } return offset + 2 } Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value >>> 8) this[offset + 1] = (value & 0xff) } else { objectWriteUInt16(this, value, offset, false) } return offset + 2 } Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value & 0xff) this[offset + 1] = (value >>> 8) this[offset + 2] = (value >>> 16) this[offset + 3] = (value >>> 24) } else { objectWriteUInt32(this, value, offset, true) } return offset + 4 } Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { value = +value offset = offset | 0 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) if (value < 0) value = 0xffffffff + value + 1 if (Buffer.TYPED_ARRAY_SUPPORT) { this[offset] = (value >>> 24) this[offset + 1] = (value >>> 16) this[offset + 2] = (value >>> 8) this[offset + 3] = (value & 0xff) } else { objectWriteUInt32(this, value, offset, false) } return offset + 4 } function checkIEEE754 (buf, value, offset, ext, max, min) { if (offset + ext > buf.length) throw new RangeError('index out of range') if (offset < 0) throw new RangeError('index out of range') } function writeFloat (buf, value, offset, littleEndian, noAssert) { if (!noAssert) { checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) } ieee754.write(buf, value, offset, littleEndian, 23, 4) return offset + 4 } Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { return writeFloat(this, value, offset, true, noAssert) } Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { return writeFloat(this, value, offset, false, noAssert) } function writeDouble (buf, value, offset, littleEndian, noAssert) { if (!noAssert) { checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) } ieee754.write(buf, value, offset, littleEndian, 52, 8) return offset + 8 } Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { return writeDouble(this, value, offset, true, noAssert) } Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { return writeDouble(this, value, offset, false, noAssert) } // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) Buffer.prototype.copy = function copy (target, targetStart, start, end) { if (!start) start = 0 if (!end && end !== 0) end = this.length if (targetStart >= target.length) targetStart = target.length if (!targetStart) targetStart = 0 if (end > 0 && end < start) end = start // Copy 0 bytes; we're done if (end === start) return 0 if (target.length === 0 || this.length === 0) return 0 // Fatal error conditions if (targetStart < 0) { throw new RangeError('targetStart out of bounds') } if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') if (end < 0) throw new RangeError('sourceEnd out of bounds') // Are we oob? if (end > this.length) end = this.length if (target.length - targetStart < end - start) { end = target.length - targetStart + start } var len = end - start var i if (this === target && start < targetStart && targetStart < end) { // descending copy from end for (i = len - 1; i >= 0; i--) { target[i + targetStart] = this[i + start] } } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { // ascending copy from start for (i = 0; i < len; i++) { target[i + targetStart] = this[i + start] } } else { Uint8Array.prototype.set.call( target, this.subarray(start, start + len), targetStart ) } return len } // fill(value, start=0, end=buffer.length) Buffer.prototype.fill = function fill (value, start, end) { if (!value) value = 0 if (!start) start = 0 if (!end) end = this.length if (end < start) throw new RangeError('end < start') // Fill 0 bytes; we're done if (end === start) return if (this.length === 0) return if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') if (end < 0 || end > this.length) throw new RangeError('end out of bounds') var i if (typeof value === 'number') { for (i = start; i < end; i++) { this[i] = value } } else { var bytes = utf8ToBytes(value.toString()) var len = bytes.length for (i = start; i < end; i++) { this[i] = bytes[i % len] } } return this } // HELPER FUNCTIONS // ================ var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g function base64clean (str) { // Node strips out invalid characters like \n and \t from the string, base64-js does not str = stringtrim(str).replace(INVALID_BASE64_RE, '') // Node converts strings with length < 2 to '' if (str.length < 2) return '' // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not while (str.length % 4 !== 0) { str = str + '=' } return str } function stringtrim (str) { if (str.trim) return str.trim() return str.replace(/^\s+|\s+$/g, '') } function toHex (n) { if (n < 16) return '0' + n.toString(16) return n.toString(16) } function utf8ToBytes (string, units) { units = units || Infinity var codePoint var length = string.length var leadSurrogate = null var bytes = [] for (var i = 0; i < length; i++) { codePoint = string.charCodeAt(i) // is surrogate component if (codePoint > 0xD7FF && codePoint < 0xE000) { // last char was a lead if (!leadSurrogate) { // no lead yet if (codePoint > 0xDBFF) { // unexpected trail if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) continue } else if (i + 1 === length) { // unpaired lead if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) continue } // valid lead leadSurrogate = codePoint continue } // 2 leads in a row if (codePoint < 0xDC00) { if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) leadSurrogate = codePoint continue } // valid surrogate pair codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 } else if (leadSurrogate) { // valid bmp char, but last char was a lead if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) } leadSurrogate = null // encode utf8 if (codePoint < 0x80) { if ((units -= 1) < 0) break bytes.push(codePoint) } else if (codePoint < 0x800) { if ((units -= 2) < 0) break bytes.push( codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80 ) } else if (codePoint < 0x10000) { if ((units -= 3) < 0) break bytes.push( codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80 ) } else if (codePoint < 0x110000) { if ((units -= 4) < 0) break bytes.push( codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80 ) } else { throw new Error('Invalid code point') } } return bytes } function asciiToBytes (str) { var byteArray = [] for (var i = 0; i < str.length; i++) { // Node's code seems to be doing this and not & 0x7F.. byteArray.push(str.charCodeAt(i) & 0xFF) } return byteArray } function utf16leToBytes (str, units) { var c, hi, lo var byteArray = [] for (var i = 0; i < str.length; i++) { if ((units -= 2) < 0) break c = str.charCodeAt(i) hi = c >> 8 lo = c % 256 byteArray.push(lo) byteArray.push(hi) } return byteArray } function base64ToBytes (str) { return base64.toByteArray(base64clean(str)) } function blitBuffer (src, dst, offset, length) { for (var i = 0; i < length; i++) { if ((i + offset >= dst.length) || (i >= src.length)) break dst[i + offset] = src[i] } return i } }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"base64-js":5,"ieee754":6,"isarray":7}],5:[function(require,module,exports){ ;(function (exports) { 'use strict' var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' var Arr = (typeof Uint8Array !== 'undefined') ? Uint8Array : Array var PLUS = '+'.charCodeAt(0) var SLASH = '/'.charCodeAt(0) var NUMBER = '0'.charCodeAt(0) var LOWER = 'a'.charCodeAt(0) var UPPER = 'A'.charCodeAt(0) var PLUS_URL_SAFE = '-'.charCodeAt(0) var SLASH_URL_SAFE = '_'.charCodeAt(0) function decode (elt) { var code = elt.charCodeAt(0) if (code === PLUS || code === PLUS_URL_SAFE) return 62 // '+' if (code === SLASH || code === SLASH_URL_SAFE) return 63 // '/' if (code < NUMBER) return -1 // no match if (code < NUMBER + 10) return code - NUMBER + 26 + 26 if (code < UPPER + 26) return code - UPPER if (code < LOWER + 26) return code - LOWER + 26 } function b64ToByteArray (b64) { var i, j, l, tmp, placeHolders, arr if (b64.length % 4 > 0) { throw new Error('Invalid string. Length must be a multiple of 4') } // the number of equal signs (place holders) // if there are two placeholders, than the two characters before it // represent one byte // if there is only one, then the three characters before it represent 2 bytes // this is just a cheap hack to not do indexOf twice var len = b64.length placeHolders = b64.charAt(len - 2) === '=' ? 2 : b64.charAt(len - 1) === '=' ? 1 : 0 // base64 is 4/3 + up to two characters of the original data arr = new Arr(b64.length * 3 / 4 - placeHolders) // if there are placeholders, only get up to the last complete 4 chars l = placeHolders > 0 ? b64.length - 4 : b64.length var L = 0 function push (v) { arr[L++] = v } for (i = 0, j = 0; i < l; i += 4, j += 3) { tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) push((tmp & 0xFF0000) >> 16) push((tmp & 0xFF00) >> 8) push(tmp & 0xFF) } if (placeHolders === 2) { tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) push(tmp & 0xFF) } else if (placeHolders === 1) { tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) push((tmp >> 8) & 0xFF) push(tmp & 0xFF) } return arr } function uint8ToBase64 (uint8) { var i var extraBytes = uint8.length % 3 // if we have 1 byte left, pad 2 bytes var output = '' var temp, length function encode (num) { return lookup.charAt(num) } function tripletToBase64 (num) { return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) } // go through the array every three bytes, we'll deal with trailing stuff later for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) output += tripletToBase64(temp) } // pad the end with zeros, but make sure to not forget the extra bytes switch (extraBytes) { case 1: temp = uint8[uint8.length - 1] output += encode(temp >> 2) output += encode((temp << 4) & 0x3F) output += '==' break case 2: temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) output += encode(temp >> 10) output += encode((temp >> 4) & 0x3F) output += encode((temp << 2) & 0x3F) output += '=' break default: break } return output } exports.toByteArray = b64ToByteArray exports.fromByteArray = uint8ToBase64 }(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) },{}],6:[function(require,module,exports){ exports.read = function (buffer, offset, isLE, mLen, nBytes) { var e, m var eLen = nBytes * 8 - mLen - 1 var eMax = (1 << eLen) - 1 var eBias = eMax >> 1 var nBits = -7 var i = isLE ? (nBytes - 1) : 0 var d = isLE ? -1 : 1 var s = buffer[offset + i] i += d e = s & ((1 << (-nBits)) - 1) s >>= (-nBits) nBits += eLen for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} m = e & ((1 << (-nBits)) - 1) e >>= (-nBits) nBits += mLen for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} if (e === 0) { e = 1 - eBias } else if (e === eMax) { return m ? NaN : ((s ? -1 : 1) * Infinity) } else { m = m + Math.pow(2, mLen) e = e - eBias } return (s ? -1 : 1) * m * Math.pow(2, e - mLen) } exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { var e, m, c var eLen = nBytes * 8 - mLen - 1 var eMax = (1 << eLen) - 1 var eBias = eMax >> 1 var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) var i = isLE ? 0 : (nBytes - 1) var d = isLE ? 1 : -1 var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 value = Math.abs(value) if (isNaN(value) || value === Infinity) { m = isNaN(value) ? 1 : 0 e = eMax } else { e = Math.floor(Math.log(value) / Math.LN2) if (value * (c = Math.pow(2, -e)) < 1) { e-- c *= 2 } if (e + eBias >= 1) { value += rt / c } else { value += rt * Math.pow(2, 1 - eBias) } if (value * c >= 2) { e++ c /= 2 } if (e + eBias >= eMax) { m = 0 e = eMax } else if (e + eBias >= 1) { m = (value * c - 1) * Math.pow(2, mLen) e = e + eBias } else { m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) e = 0 } } for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} e = (e << mLen) | m eLen += mLen for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} buffer[offset + i - d] |= s * 128 } },{}],7:[function(require,module,exports){ var toString = {}.toString; module.exports = Array.isArray || function (arr) { return toString.call(arr) == '[object Array]'; }; },{}],8:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. // resolves . and .. elements in a path array with directory names there // must be no slashes, empty elements, or device names (c:\) in the array // (so also no leading and trailing slashes - it does not distinguish // relative and absolute paths) function normalizeArray(parts, allowAboveRoot) { // if the path tries to go above the root, `up` ends up > 0 var up = 0; for (var i = parts.length - 1; i >= 0; i--) { var last = parts[i]; if (last === '.') { parts.splice(i, 1); } else if (last === '..') { parts.splice(i, 1); up++; } else if (up) { parts.splice(i, 1); up--; } } // if the path is allowed to go above the root, restore leading ..s if (allowAboveRoot) { for (; up--; up) { parts.unshift('..'); } } return parts; } // Split a filename into [root, dir, basename, ext], unix version // 'root' is just a slash, or nothing. var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; var splitPath = function(filename) { return splitPathRe.exec(filename).slice(1); }; // path.resolve([from ...], to) // posix version exports.resolve = function() { var resolvedPath = '', resolvedAbsolute = false; for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { var path = (i >= 0) ? arguments[i] : process.cwd(); // Skip empty and invalid entries if (typeof path !== 'string') { throw new TypeError('Arguments to path.resolve must be strings'); } else if (!path) { continue; } resolvedPath = path + '/' + resolvedPath; resolvedAbsolute = path.charAt(0) === '/'; } // At this point the path should be resolved to a full absolute path, but // handle relative paths to be safe (might happen when process.cwd() fails) // Normalize the path resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { return !!p; }), !resolvedAbsolute).join('/'); return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; }; // path.normalize(path) // posix version exports.normalize = function(path) { var isAbsolute = exports.isAbsolute(path), trailingSlash = substr(path, -1) === '/'; // Normalize the path path = normalizeArray(filter(path.split('/'), function(p) { return !!p; }), !isAbsolute).join('/'); if (!path && !isAbsolute) { path = '.'; } if (path && trailingSlash) { path += '/'; } return (isAbsolute ? '/' : '') + path; }; // posix version exports.isAbsolute = function(path) { return path.charAt(0) === '/'; }; // posix version exports.join = function() { var paths = Array.prototype.slice.call(arguments, 0); return exports.normalize(filter(paths, function(p, index) { if (typeof p !== 'string') { throw new TypeError('Arguments to path.join must be strings'); } return p; }).join('/')); }; // path.relative(from, to) // posix version exports.relative = function(from, to) { from = exports.resolve(from).substr(1); to = exports.resolve(to).substr(1); function trim(arr) { var start = 0; for (; start < arr.length; start++) { if (arr[start] !== '') break; } var end = arr.length - 1; for (; end >= 0; end--) { if (arr[end] !== '') break; } if (start > end) return []; return arr.slice(start, end - start + 1); } var fromParts = trim(from.split('/')); var toParts = trim(to.split('/')); var length = Math.min(fromParts.length, toParts.length); var samePartsLength = length; for (var i = 0; i < length; i++) { if (fromParts[i] !== toParts[i]) { samePartsLength = i; break; } } var outputParts = []; for (var i = samePartsLength; i < fromParts.length; i++) { outputParts.push('..'); } outputParts = outputParts.concat(toParts.slice(samePartsLength)); return outputParts.join('/'); }; exports.sep = '/'; exports.delimiter = ':'; exports.dirname = function(path) { var result = splitPath(path), root = result[0], dir = result[1]; if (!root && !dir) { // No dirname whatsoever return '.'; } if (dir) { // It has a dirname, strip trailing slash dir = dir.substr(0, dir.length - 1); } return root + dir; }; exports.basename = function(path, ext) { var f = splitPath(path)[2]; // TODO: make this comparison case-insensitive on windows? if (ext && f.substr(-1 * ext.length) === ext) { f = f.substr(0, f.length - ext.length); } return f; }; exports.extname = function(path) { return splitPath(path)[3]; }; function filter (xs, f) { if (xs.filter) return xs.filter(f); var res = []; for (var i = 0; i < xs.length; i++) { if (f(xs[i], i, xs)) res.push(xs[i]); } return res; } // String.prototype.substr - negative index don't work in IE8 var substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) { return str.substr(start, len) } : function (str, start, len) { if (start < 0) start = str.length + start; return str.substr(start, len); } ; }).call(this,require('_process')) },{"_process":9}],9:[function(require,module,exports){ // shim for using process in browser var process = module.exports = {}; var queue = []; var draining = false; var currentQueue; var queueIndex = -1; function cleanUpNextTick() { draining = false; if (currentQueue.length) { queue = currentQueue.concat(queue); } else { queueIndex = -1; } if (queue.length) { drainQueue(); } } function drainQueue() { if (draining) { return; } var timeout = setTimeout(cleanUpNextTick); draining = true; var len = queue.length; while(len) { currentQueue = queue; queue = []; while (++queueIndex < len) { if (currentQueue) { currentQueue[queueIndex].run(); } } queueIndex = -1; len = queue.length; } currentQueue = null; draining = false; clearTimeout(timeout); } process.nextTick = function (fun) { var args = new Array(arguments.length - 1); if (arguments.length > 1) { for (var i = 1; i < arguments.length; i++) { args[i - 1] = arguments[i]; } } queue.push(new Item(fun, args)); if (queue.length === 1 && !draining) { setTimeout(drainQueue, 0); } }; // v8 likes predictible objects function Item(fun, array) { this.fun = fun; this.array = array; } Item.prototype.run = function () { this.fun.apply(null, this.array); }; process.title = 'browser'; process.browser = true; process.env = {}; process.argv = []; process.version = ''; // empty string to avoid regexp issues process.versions = {}; function noop() {} process.on = noop; process.addListener = noop; process.once = noop; process.off = noop; process.removeListener = noop; process.removeAllListeners = noop; process.emit = noop; process.binding = function (name) { throw new Error('process.binding is not supported'); }; process.cwd = function () { return '/' }; process.chdir = function (dir) { throw new Error('process.chdir is not supported'); }; process.umask = function() { return 0; }; },{}],10:[function(require,module,exports){ var ohm = require('..'); module.exports = ohm.makeRecipe(function() { var decl = this.newGrammar("BuiltInRules") .withSource("BuiltInRules {\n\n alnum (an alpha-numeric character)\n = letter\n | digit\n\n letter (a letter)\n = lower\n | upper\n | unicodeLtmo\n\n digit (a digit)\n = \"0\"..\"9\"\n\n hexDigit (a hexadecimal digit)\n = digit\n | \"a\"..\"f\"\n | \"A\"..\"F\"\n\n ListOf\n = NonemptyListOf\n | EmptyListOf\n\n NonemptyListOf\n = elem (sep elem)*\n\n EmptyListOf\n = /* nothing */\n\n listOf\n = nonemptyListOf\n | emptyListOf\n\n nonemptyListOf\n = elem (sep elem)*\n\n emptyListOf\n = /* nothing */\n\n}") return decl .define("alnum", [], this.alt(this.app("letter").withInterval(decl.sourceInterval(60, 66)), this.app("digit").withInterval(decl.sourceInterval(73, 78))).withInterval(decl.sourceInterval(60, 78)), "an alpha-numeric character") .define("letter", [], this.alt(this.app("lower").withInterval(decl.sourceInterval(107, 112)), this.app("upper").withInterval(decl.sourceInterval(119, 124)), this.app("unicodeLtmo").withInterval(decl.sourceInterval(131, 142))).withInterval(decl.sourceInterval(107, 142)), "a letter") .define("digit", [], this.range("0", "9").withInterval(decl.sourceInterval(169, 177)), "a digit") .define("hexDigit", [], this.alt(this.app("digit").withInterval(decl.sourceInterval(219, 224)), this.range("a", "f").withInterval(decl.sourceInterval(231, 239)), this.range("A", "F").withInterval(decl.sourceInterval(246, 254))).withInterval(decl.sourceInterval(219, 254)), "a hexadecimal digit") .define("ListOf", ["elem", "sep"], this.alt(this.app("NonemptyListOf", [this.param(0), this.param(1)]).withInterval(decl.sourceInterval(282, 307)), this.app("EmptyListOf", [this.param(0), this.param(1)]).withInterval(decl.sourceInterval(314, 336))).withInterval(decl.sourceInterval(282, 336))) .define("NonemptyListOf", ["elem", "sep"], this.seq(this.param(0), this.star(this.seq(this.param(1), this.param(0)).withInterval(decl.sourceInterval(378, 386))).withInterval(decl.sourceInterval(377, 388))).withInterval(decl.sourceInterval(372, 388))) .define("EmptyListOf", ["elem", "sep"], this.seq().withInterval(decl.sourceInterval(438, 438))) .define("listOf", ["elem", "sep"], this.alt(this.app("nonemptyListOf", [this.param(0), this.param(1)]).withInterval(decl.sourceInterval(462, 487)), this.app("emptyListOf", [this.param(0), this.param(1)]).withInterval(decl.sourceInterval(494, 516))).withInterval(decl.sourceInterval(462, 516))) .define("nonemptyListOf", ["elem", "sep"], this.seq(this.param(0), this.star(this.seq(this.param(1), this.param(0)).withInterval(decl.sourceInterval(558, 566))).withInterval(decl.sourceInterval(557, 568))).withInterval(decl.sourceInterval(552, 568))) .define("emptyListOf", ["elem", "sep"], this.seq().withInterval(decl.sourceInterval(616, 616))) .build(); }); },{"..":50}],11:[function(require,module,exports){ var ohm = require('..'); module.exports = ohm.makeRecipe(function() { var decl = this.newGrammar("Ohm") .withSource("Ohm {\n\n Grammars\n = Grammar*\n\n Grammar\n = ident SuperGrammar? \"{\" Rule* \"}\"\n\n SuperGrammar\n = \"<:\" ident\n\n Rule\n = ident Formals? ruleDescr? \"=\" \"|\"? Alt -- define\n | ident Formals? \":=\" \"|\"? Alt -- override\n | ident Formals? \"+=\" \"|\"? Alt -- extend\n\n Formals\n = \"<\" ListOf \">\"\n\n Params\n = \"<\" ListOf \">\"\n\n Alt\n = Term (\"|\" Term)*\n\n Term\n = Seq caseName -- inline\n | Seq\n\n Seq\n = Iter*\n\n Iter\n = Pred \"*\" -- star\n | Pred \"+\" -- plus\n | Pred \"?\" -- opt\n | Pred\n\n Pred\n = \"~\" Modifier -- not\n | \"&\" Modifier -- lookahead\n | Modifier\n\n Modifier\n = \"#\" Base -- lex\n | \"$\" Base -- val\n | Base\n\n Base\n = ident Params? ~(ruleDescr? \"=\" | \":=\" | \"+=\") -- application\n | Prim \"..\" Prim -- range\n | Prim -- prim\n | \"(\" Alt \")\" -- paren\n | \"[\" Alt \"]\" -- arr\n | \"{\" \"...\"? \"}\" -- obj\n | \"{\" Props (\",\" \"...\")? \"}\" -- objWithProps\n\n Prim\n = keyword\n | string\n | number\n\n Props\n = Prop (\",\" Prop)*\n\n Prop\n = (name | string) \":\" Alt\n\n ruleDescr (a rule description)\n = \"(\" ruleDescrText \")\"\n\n ruleDescrText\n = (~\")\" any)*\n\n caseName\n = \"--\" (~\"\\n\" space)* name (~\"\\n\" space)* (\"\\n\" | &\"}\")\n\n name (a name)\n = nameFirst nameRest*\n\n nameFirst\n = \"_\"\n | letter\n\n nameRest\n = \"_\"\n | alnum\n\n ident (an identifier)\n = ~keyword name\n\n keyword\n = \"null\" ~nameRest -- null\n | \"true\" ~nameRest -- true\n | \"false\" ~nameRest -- false\n\n string\n = \"\\\"\" strChar* \"\\\"\"\n\n strChar\n = escapeChar\n | ~\"\\\\\" ~\"\\\"\" ~\"\\n\" any\n\n escapeChar (an escape sequence)\n = \"\\\\\\\\\" -- backslash\n | \"\\\\\\\"\" -- doubleQuote\n | \"\\\\\\'\" -- singleQuote\n | \"\\\\b\" -- backspace\n | \"\\\\n\" -- lineFeed\n | \"\\\\r\" -- carriageReturn\n | \"\\\\t\" -- tab\n | \"\\\\u\" hexDigit hexDigit hexDigit hexDigit -- unicodeEscape\n | \"\\\\x\" hexDigit hexDigit -- hexEscape\n\n number (a number)\n = \"-\"? digit+\n\n space\n += comment\n\n comment\n = \"//\" (~\"\\n\" any)* \"\\n\" -- singleLine\n | \"/*\" (~\"*/\" any)* \"*/\" -- multiLine\n\n tokens = token*\n\n token = caseName | comment | ident | keyword | number | operator | punctuation | string | any\n\n operator = \"<:\" | \"=\" | \":=\" | \"+=\" | \"*\" | \"+\" | \"?\" | \"~\" | \"&\"\n\n punctuation = \"<\" | \">\" | \",\" | \"--\"\n}") .withDefaultStartRule("Grammars") return decl .define("Grammars", [], this.star(this.app("Grammar").withInterval(decl.sourceInterval(24, 31))).withInterval(decl.sourceInterval(24, 32))) .define("Grammar", [], this.seq(this.app("ident").withInterval(decl.sourceInterval(50, 55)), this.opt(this.app("SuperGrammar").withInterval(decl.sourceInterval(56, 68))).withInterval(decl.sourceInterval(56, 69)), this.prim("{").withInterval(decl.sourceInterval(70, 73)), this.star(this.app("Rule").withInterval(decl.sourceInterval(74, 78))).withInterval(decl.sourceInterval(74, 79)), this.prim("}").withInterval(decl.sourceInterval(80, 83))).withInterval(decl.sourceInterval(50, 83))) .define("SuperGrammar", [], this.seq(this.prim("<:").withInterval(decl.sourceInterval(106, 110)), this.app("ident").withInterval(decl.sourceInterval(111, 116))).withInterval(decl.sourceInterval(106, 116))) .define("Rule_define", [], this.seq(this.app("ident").withInterval(decl.sourceInterval(131, 136)), this.opt(this.app("Formals").withInterval(decl.sourceInterval(137, 144))).withInterval(decl.sourceInterval(137, 145)), this.opt(this.app("ruleDescr").withInterval(decl.sourceInterval(146, 155))).withInterval(decl.sourceInterval(146, 156)), this.prim("=").withInterval(decl.sourceInterval(157, 160)), this.opt(this.prim("|").withInterval(decl.sourceInterval(162, 165))).withInterval(decl.sourceInterval(162, 166)), this.app("Alt").withInterval(decl.sourceInterval(167, 170))).withInterval(decl.sourceInterval(131, 170))) .define("Rule_override", [], this.seq(this.app("ident").withInterval(decl.sourceInterval(188, 193)), this.opt(this.app("Formals").withInterval(decl.sourceInterval(194, 201))).withInterval(decl.sourceInterval(194, 202)), this.prim(":=").withInterval(decl.sourceInterval(214, 218)), this.opt(this.prim("|").withInterval(decl.sourceInterval(219, 222))).withInterval(decl.sourceInterval(219, 223)), this.app("Alt").withInterval(decl.sourceInterval(224, 227))).withInterval(decl.sourceInterval(188, 227))) .define("Rule_extend", [], this.seq(this.app("ident").withInterval(decl.sourceInterval(247, 252)), this.opt(this.app("Formals").withInterval(decl.sourceInterval(253, 260))).withInterval(decl.sourceInterval(253, 261)), this.prim("+=").withInterval(decl.sourceInterval(273, 277)), this.opt(this.prim("|").withInterval(decl.sourceInterval(278, 281))).withInterval(decl.sourceInterval(278, 282)), this.app("Alt").withInterval(decl.sourceInterval(283, 286))).withInterval(decl.sourceInterval(247, 286))) .define("Rule", [], this.alt(this.app("Rule_define").withInterval(decl.sourceInterval(131, 170)), this.app("Rule_override").withInterval(decl.sourceInterval(188, 227)), this.app("Rule_extend").withInterval(decl.sourceInterval(247, 286))).withInterval(decl.sourceInterval(131, 297))) .define("Formals", [], this.seq(this.prim("<").withInterval(decl.sourceInterval(315, 318)), this.app("ListOf", [this.app("ident").withInterval(decl.sourceInterval(326, 331)), this.prim(",").withInterval(decl.sourceInterval(333, 336))]).withInterval(decl.sourceInterval(319, 337)), this.prim(">").withInterval(decl.sourceInterval(338, 341))).withInterval(decl.sourceInterval(315, 341))) .define("Params", [], this.seq(this.prim("<").withInterval(decl.sourceInterval(358, 361)), this.app("ListOf", [this.app("Seq").withInterval(decl.sourceInterval(369, 372)), this.prim(",").withInterval(decl.sourceInterval(374, 377))]).withInterval(decl.sourceInterval(362, 378)), this.prim(">").withInterval(decl.sourceInterval(379, 382))).withInterval(decl.sourceInterval(358, 382))) .define("Alt", [], this.seq(this.app("Term").withInterval(decl.sourceInterval(396, 400)), this.star(this.seq(this.prim("|").withInterval(decl.sourceInterval(402, 405)), this.app("Term").withInterval(decl.sourceInterval(406, 410))).withInterval(decl.sourceInterval(402, 410))).withInterval(decl.sourceInterval(401, 412))).withInterval(decl.sourceInterval(396, 412))) .define("Term_inline", [], this.seq(this.app("Seq").withInterval(decl.sourceInterval(427, 430)), this.app("caseName").withInterval(decl.sourceInterval(431, 439))).withInterval(decl.sourceInterval(427, 439))) .define("Term", [], this.alt(this.app("Term_inline").withInterval(decl.sourceInterval(427, 439)), this.app("Seq").withInterval(decl.sourceInterval(456, 459))).withInterval(decl.sourceInterval(427, 459))) .define("Seq", [], this.star(this.app("Iter").withInterval(decl.sourceInterval(473, 477))).withInterval(decl.sourceInterval(473, 478))) .define("Iter_star", [], this.seq(this.app("Pred").withInterval(decl.sourceInterval(493, 497)), this.prim("*").withInterval(decl.sourceInterval(498, 501))).withInterval(decl.sourceInterval(493, 501))) .define("Iter_plus", [], this.seq(this.app("Pred").withInterval(decl.sourceInterval(517, 521)), this.prim("+").withInterval(decl.sourceInterval(522, 525))).withInterval(decl.sourceInterval(517, 525))) .define("Iter_opt", [], this.seq(this.app("Pred").withInterval(decl.sourceInterval(541, 545)), this.prim("?").withInterval(decl.sourceInterval(546, 549))).withInterval(decl.sourceInterval(541, 549))) .define("Iter", [], this.alt(this.app("Iter_star").withInterval(decl.sourceInterval(493, 501)), this.app("Iter_plus").withInterval(decl.sourceInterval(517, 525)), this.app("Iter_opt").withInterval(decl.sourceInterval(541, 549)), this.app("Pred").withInterval(decl.sourceInterval(564, 568))).withInterval(decl.sourceInterval(493, 568))) .define("Pred_not", [], this.seq(this.prim("~").withInterval(decl.sourceInterval(583, 586)), this.app("Modifier").withInterval(decl.sourceInterval(587, 595))).withInterval(decl.sourceInterval(583, 595))) .define("Pred_lookahead", [], this.seq(this.prim("&").withInterval(decl.sourceInterval(610, 613)), this.app("Modifier").withInterval(decl.sourceInterval(614, 622))).withInterval(decl.sourceInterval(610, 622))) .define("Pred", [], this.alt(this.app("Pred_not").withInterval(decl.sourceInterval(583, 595)), this.app("Pred_lookahead").withInterval(decl.sourceInterval(610, 622)), this.app("Modifier").withInterval(decl.sourceInterval(643, 651))).withInterval(decl.sourceInterval(583, 651))) .define("Modifier_lex", [], this.seq(this.prim("#").withInterval(decl.sourceInterval(670, 673)), this.app("Base").withInterval(decl.sourceInterval(674, 678))).withInterval(decl.sourceInterval(670, 678))) .define("Modifier_val", [], this.seq(this.prim("$").withInterval(decl.sourceInterval(693, 696)), this.app("Base").withInterval(decl.sourceInterval(697, 701))).withInterval(decl.sourceInterval(693, 701))) .define("Modifier", [], this.alt(this.app("Modifier_lex").withInterval(decl.sourceInterval(670, 678)), this.app("Modifier_val").withInterval(decl.sourceInterval(693, 701)), this.app("Base").withInterval(decl.sourceInterval(716, 720))).withInterval(decl.sourceInterval(670, 720))) .define("Base_application", [], this.seq(this.app("ident").withInterval(decl.sourceInterval(735, 740)), this.opt(this.app("Params").withInterval(decl.sourceInterval(741, 747))).withInterval(decl.sourceInterval(741, 748)), this.not(this.alt(this.seq(this.opt(this.app("ruleDescr").withInterval(decl.sourceInterval(751, 760))).withInterval(decl.sourceInterval(751, 761)), this.prim("=").withInterval(decl.sourceInterval(762, 765))).withInterval(decl.sourceInterval(751, 765)), this.prim(":=").withInterval(decl.sourceInterval(768, 772)), this.prim("+=").withInterval(decl.sourceInterval(775, 779))).withInterval(decl.sourceInterval(751, 779))).withInterval(decl.sourceInterval(749, 780))).withInterval(decl.sourceInterval(735, 780))) .define("Base_range", [], this.seq(this.app("Prim").withInterval(decl.sourceInterval(803, 807)), this.prim("..").withInterval(decl.sourceInterval(808, 812)), this.app("Prim").withInterval(decl.sourceInterval(813, 817))).withInterval(decl.sourceInterval(803, 817))) .define("Base_prim", [], this.app("Prim").withInterval(decl.sourceInterval(865, 869))) .define("Base_paren", [], this.seq(this.prim("(").withInterval(decl.sourceInterval(926, 929)), this.app("Alt").withInterval(decl.sourceInterval(930, 933)), this.prim(")").withInterval(decl.sourceInterval(934, 937))).withInterval(decl.sourceInterval(926, 937))) .define("Base_arr", [], this.seq(this.prim("[").withInterval(decl.sourceInterval(988, 991)), this.app("Alt").withInterval(decl.sourceInterval(992, 995)), this.prim("]").withInterval(decl.sourceInterval(996, 999))).withInterval(decl.sourceInterval(988, 999))) .define("Base_obj", [], this.seq(this.prim("{").withInterval(decl.sourceInterval(1048, 1051)), this.opt(this.prim("...").withInterval(decl.sourceInterval(1052, 1057))).withInterval(decl.sourceInterval(1052, 1058)), this.prim("}").withInterval(decl.sourceInterval(1059, 1062))).withInterval(decl.sourceInterval(1048, 1062))) .define("Base_objWithProps", [], this.seq(this.prim("{").withInterval(decl.sourceInterval(1108, 1111)), this.app("Props").withInterval(decl.sourceInterval(1112, 1117)), this.opt(this.seq(this.prim(",").withInterval(decl.sourceInterval(1119, 1122)), this.prim("...").withInterval(decl.sourceInterval(1123, 1128))).withInterval(decl.sourceInterval(1119, 1128))).withInterval(decl.sourceInterval(1118, 1130)), this.prim("}").withInterval(decl.sourceInterval(1131, 1134))).withInterval(decl.sourceInterval(1108, 1134))) .define("Base", [], this.alt(this.app("Base_application").withInterval(decl.sourceInterval(735, 780)), this.app("Base_range").withInterval(decl.sourceInterval(803, 817)), this.app("Base_prim").withInterval(decl.sourceInterval(865, 869)), this.app("Base_paren").withInterval(decl.sourceInterval(926, 937)), this.app("Base_arr").withInterval(decl.sourceInterval(988, 999)), this.app("Base_obj").withInterval(decl.sourceInterval(1048, 1062)), this.app("Base_objWithProps").withInterval(decl.sourceInterval(1108, 1134))).withInterval(decl.sourceInterval(735, 1170))) .define("Prim", [], this.alt(this.app("keyword").withInterval(decl.sourceInterval(1185, 1192)), this.app("string").withInterval(decl.sourceInterval(1199, 1205)), this.app("number").withInterval(decl.sourceInterval(1212, 1218))).withInterval(decl.sourceInterval(1185, 1218))) .define("Props", [], this.seq(this.app("Prop").withInterval(decl.sourceInterval(1234, 1238)), this.star(this.seq(this.prim(",").withInterval(decl.sourceInterval(1240, 1243)), this.app("Prop").withInterval(decl.sourceInterval(1244, 1248))).withInterval(decl.sourceInterval(1240, 1248))).withInterval(decl.sourceInterval(1239, 1250))).withInterval(decl.sourceInterval(1234, 1250))) .define("Prop", [], this.seq(this.alt(this.app("name").withInterval(decl.sourceInterval(1266, 1270)), this.app("string").withInterval(decl.sourceInterval(1273, 1279))).withInterval(decl.sourceInterval(1266, 1279)), this.prim(":").withInterval(decl.sourceInterval(1281, 1284)), this.app("Alt").withInterval(decl.sourceInterval(1285, 1288))).withInterval(decl.sourceInterval(1265, 1288))) .define("ruleDescr", [], this.seq(this.prim("(").withInterval(decl.sourceInterval(1330, 1333)), this.app("ruleDescrText").withInterval(decl.sourceInterval(1334, 1347)), this.prim(")").withInterval(decl.sourceInterval(1348, 1351))).withInterval(decl.sourceInterval(1330, 1351)), "a rule description") .define("ruleDescrText", [], this.star(this.seq(this.not(this.prim(")").withInterval(decl.sourceInterval(1377, 1380))).withInterval(decl.sourceInterval(1376, 1380)), this.app("any").withInterval(decl.sourceInterval(1381, 1384))).withInterval(decl.sourceInterval(1376, 1384))).withInterval(decl.sourceInterval(1375, 1386))) .define("caseName", [], this.seq(this.prim("--").withInterval(decl.sourceInterval(1405, 1409)), this.star(this.seq(this.not(this.prim("\n").withInterval(decl.sourceInterval(1412, 1416))).withInterval(decl.sourceInterval(1411, 1416)), this.app("space").withInterval(decl.sourceInterval(1417, 1422))).withInterval(decl.sourceInterval(1411, 1422))).withInterval(decl.sourceInterval(1410, 1424)), this.app("name").withInterval(decl.sourceInterval(1425, 1429)), this.star(this.seq(this.not(this.prim("\n").withInterval(decl.sourceInterval(1432, 1436))).withInterval(decl.sourceInterval(1431, 1436)), this.app("space").withInterval(decl.sourceInterval(1437, 1442))).withInterval(decl.sourceInterval(1431, 1442))).withInterval(decl.sourceInterval(1430, 1444)), this.alt(this.prim("\n").withInterval(decl.sourceInterval(1446, 1450)), this.la(this.prim("}").withInterval(decl.sourceInterval(1454, 1457))).withInterval(decl.sourceInterval(1453, 1457))).withInterval(decl.sourceInterval(1446, 1457))).withInterval(decl.sourceInterval(1405, 1458))) .define("name", [], this.seq(this.app("nameFirst").withInterval(decl.sourceInterval(1483, 1492)), this.star(this.app("nameRest").withInterval(decl.sourceInterval(1493, 1501))).withInterval(decl.sourceInterval(1493, 1502))).withInterval(decl.sourceInterval(1483, 1502)), "a name") .define("nameFirst", [], this.alt(this.prim("_").withInterval(decl.sourceInterval(1522, 1525)), this.app("letter").withInterval(decl.sourceInterval(1532, 1538))).withInterval(decl.sourceInterval(1522, 1538))) .define("nameRest", [], this.alt(this.prim("_").withInterval(decl.sourceInterval(1557, 1560)), this.app("alnum").withInterval(decl.sourceInterval(1567, 1572))).withInterval(decl.sourceInterval(1557, 1572))) .define("ident", [], this.seq(this.not(this.app("keyword").withInterval(decl.sourceInterval(1606, 1613))).withInterval(decl.sourceInterval(1605, 1613)), this.app("name").withInterval(decl.sourceInterval(1614, 1618))).withInterval(decl.sourceInterval(1605, 1618)), "an identifier") .define("keyword_null", [], this.seq(this.prim("null").withInterval(decl.sourceInterval(1636, 1642)), this.not(this.app("nameRest").withInterval(decl.sourceInterval(1644, 1652))).withInterval(decl.sourceInterval(1643, 1652))).withInterval(decl.sourceInterval(1636, 1652))) .define("keyword_true", [], this.seq(this.prim("true").withInterval(decl.sourceInterval(1669, 1675)), this.not(this.app("nameRest").withInterval(decl.sourceInterval(1677, 1685))).withInterval(decl.sourceInterval(1676, 1685))).withInterval(decl.sourceInterval(1669, 1685))) .define("keyword_false", [], this.seq(this.prim("false").withInterval(decl.sourceInterval(1702, 1709)), this.not(this.app("nameRest").withInterval(decl.sourceInterval(1711, 1719))).withInterval(decl.sourceInterval(1710, 1719))).withInterval(decl.sourceInterval(1702, 1719))) .define("keyword", [], this.alt(this.app("keyword_null").withInterval(decl.sourceInterval(1636, 1652)), this.app("keyword_true").withInterval(decl.sourceInterval(1669, 1685)), this.app("keyword_false").withInterval(decl.sourceInterval(1702, 1719))).withInterval(decl.sourceInterval(1636, 1729))) .define("string", [], this.seq(this.prim("\"").withInterval(decl.sourceInterval(1746, 1750)), this.star(this.app("strChar").withInterval(decl.sourceInterval(1751, 1758))).withInterval(decl.sourceInterval(1751, 1759)), this.prim("\"").withInterval(decl.sourceInterval(1760, 1764))).withInterval(decl.sourceInterval(1746, 1764))) .define("strChar", [], this.alt(this.app("escapeChar").withInterval(decl.sourceInterval(1782, 1792)), this.seq(this.not(this.prim("\\").withInterval(decl.sourceInterval(1800, 1804))).withInterval(decl.sourceInterval(1799, 1804)), this.not(this.prim("\"").withInterval(decl.sourceInterval(1806, 1810))).withInterval(decl.sourceInterval(1805, 1810)), this.not(this.prim("\n").withInterval(decl.sourceInterval(1812, 1816))).withInterval(decl.sourceInterval(1811, 1816)), this.app("any").withInterval(decl.sourceInterval(1817, 1820))).withInterval(decl.sourceInterval(1799, 1820))).withInterval(decl.sourceInterval(1782, 1820))) .define("escapeChar_backslash", [], this.prim("\\\\").withInterval(decl.sourceInterval(1863, 1869))) .define("escapeChar_doubleQuote", [], this.prim("\\\"").withInterval(decl.sourceInterval(1925, 1931))) .define("escapeChar_singleQuote", [], this.prim("\\'").withInterval(decl.sourceInterval(1989, 1995))) .define("escapeChar_backspace", [], this.prim("\\b").withInterval(decl.sourceInterval(2053, 2058))) .define("escapeChar_lineFeed", [], this.prim("\\n").withInterval(decl.sourceInterval(2115, 2120))) .define("escapeChar_carriageReturn", [], this.prim("\\r").withInterval(decl.sourceInterval(2176, 2181))) .define("escapeChar_tab", [], this.prim("\\t").withInterval(decl.sourceInterval(2243, 2248))) .define("escapeChar_unicodeEscape", [], this.seq(this.prim("\\u").withInterval(decl.sourceInterval(2299, 2304)), this.app("hexDigit").withInterval(decl.sourceInterval(2305, 2313)), this.app("hexDigit").withInterval(decl.sourceInterval(2314, 2322)), this.app("hexDigit").withInterval(decl.sourceInterval(2323, 2331)), this.app("hexDigit").withInterval(decl.sourceInterval(2332, 2340))).withInterval(decl.sourceInterval(2299, 2340))) .define("escapeChar_hexEscape", [], this.seq(this.prim("\\x").withInterval(decl.sourceInterval(2365, 2370)), this.app("hexDigit").withInterval(decl.sourceInterval(2371, 2379)), this.app("hexDigit").withInterval(decl.sourceInterval(2380, 2388))).withInterval(decl.sourceInterval(2365, 2388))) .define("escapeChar", [], this.alt(this.app("escapeChar_backslash").withInterval(decl.sourceInterval(1863, 1869)), this.app("escapeChar_doubleQuote").withInterval(decl.sourceInterval(1925, 1931)), this.app("escapeChar_singleQuote").withInterval(decl.sourceInterval(1989, 1995)), this.app("escapeChar_backspace").withInterval(decl.sourceInterval(2053, 2058)), this.app("escapeChar_lineFeed").withInterval(decl.sourceInterval(2115, 2120)), this.app("escapeChar_carriageReturn").withInterval(decl.sourceInterval(2176, 2181)), this.app("escapeChar_tab").withInterval(decl.sourceInterval(2243, 2248)), this.app("escapeChar_unicodeEscape").withInterval(decl.sourceInterval(2299, 2340)), this.app("escapeChar_hexEscape").withInterval(decl.sourceInterval(2365, 2388))).withInterval(decl.sourceInterval(1863, 2420)), "an escape sequence") .define("number", [], this.seq(this.opt(this.prim("-").withInterval(decl.sourceInterval(2449, 2452))).withInterval(decl.sourceInterval(2449, 2453)), this.plus(this.app("digit").withInterval(decl.sourceInterval(2454, 2459))).withInterval(decl.sourceInterval(2454, 2460))).withInterval(decl.sourceInterval(2449, 2460)), "a number") .extend("space", [], this.app("comment").withInterval(decl.sourceInterval(2476, 2483))) .define("comment_singleLine", [], this.seq(this.prim("//").withInterval(decl.sourceInterval(2501, 2505)), this.star(this.seq(this.not(this.prim("\n").withInterval(decl.sourceInterval(2508, 2512))).withInterval(decl.sourceInterval(2507, 2512)), this.app("any").withInterval(decl.sourceInterval(2513, 2516))).withInterval(decl.sourceInterval(2507, 2516))).withInterval(decl.sourceInterval(2506, 2518)), this.prim("\n").withInterval(decl.sourceInterval(2519, 2523))).withInterval(decl.sourceInterval(2501, 2523))) .define("comment_multiLine", [], this.seq(this.prim("/*").withInterval(decl.sourceInterval(2545, 2549)), this.star(this.seq(this.not(this.prim("*/").withInterval(decl.sourceInterval(2552, 2556))).withInterval(decl.sourceInterval(2551, 2556)), this.app("any").withInterval(decl.sourceInterval(2557, 2560))).withInterval(decl.sourceInterval(2551, 2560))).withInterval(decl.sourceInterval(2550, 2562)), this.prim("*/").withInterval(decl.sourceInterval(2563, 2567))).withInterval(decl.sourceInterval(2545, 2567))) .define("comment", [], this.alt(this.app("comment_singleLine").withInterval(decl.sourceInterval(2501, 2523)), this.app("comment_multiLine").withInterval(decl.sourceInterval(2545, 2567))).withInterval(decl.sourceInterval(2501, 2581))) .define("tokens", [], this.star(this.app("token").withInterval(decl.sourceInterval(2594, 2599))).withInterval(decl.sourceInterval(2594, 2600))) .define("token", [], this.alt(this.app("caseName").withInterval(decl.sourceInterval(2612, 2620)), this.app("comment").withInterval(decl.sourceInterval(2623, 2630)), this.app("ident").withInterval(decl.sourceInterval(2633, 2638)), this.app("keyword").withInterval(decl.sourceInterval(2641, 2648)), this.app("number").withInterval(decl.sourceInterval(2651, 2657)), this.app("operator").withInterval(decl.sourceInterval(2660, 2668)), this.app("punctuation").withInterval(decl.sourceInterval(2671, 2682)), this.app("string").withInterval(decl.sourceInterval(2685, 2691)), this.app("any").withInterval(decl.sourceInterval(2694, 2697))).withInterval(decl.sourceInterval(2612, 2697))) .define("operator", [], this.alt(this.prim("<:").withInterval(decl.sourceInterval(2712, 2716)), this.prim("=").withInterval(decl.sourceInterval(2719, 2722)), this.prim(":=").withInterval(decl.sourceInterval(2725, 2729)), this.prim("+=").withInterval(decl.sourceInterval(2732, 2736)), this.prim("*").withInterval(decl.sourceInterval(2739, 2742)), this.prim("+").withInterval(decl.sourceInterval(2745, 2748)), this.prim("?").withInterval(decl.sourceInterval(2751, 2754)), this.prim("~").withInterval(decl.sourceInterval(2757, 2760)), this.prim("&").withInterval(decl.sourceInterval(2763, 2766))).withInterval(decl.sourceInterval(2712, 2766))) .define("punctuation", [], this.alt(this.prim("<").withInterval(decl.sourceInterval(2784, 2787)), this.prim(">").withInterval(decl.sourceInterval(2790, 2793)), this.prim(",").withInterval(decl.sourceInterval(2796, 2799)), this.prim("--").withInterval(decl.sourceInterval(2802, 2806))).withInterval(decl.sourceInterval(2784, 2806))) .build(); }); },{"..":50}],12:[function(require,module,exports){ var ohm = require('..'); module.exports = ohm.makeRecipe(function() { var decl = this.newGrammar("OperationsAndAttributes") .withSource("OperationsAndAttributes {\n\n NameNoFormals =\n name\n\n NameAndFormals =\n name Formals?\n\n Formals\n = \"(\" ListOf \")\"\n\n name (a name)\n = nameFirst nameRest*\n\n nameFirst\n = \"_\"\n | letter\n\n nameRest\n = \"_\"\n | alnum\n\n}") .withDefaultStartRule("NameNoFormals") return decl .define("NameNoFormals", [], this.app("name").withInterval(decl.sourceInterval(49, 53))) .define("NameAndFormals", [], this.seq(this.app("name").withInterval(decl.sourceInterval(78, 82)), this.opt(this.app("Formals").withInterval(decl.sourceInterval(83, 90))).withInterval(decl.sourceInterval(83, 91))).withInterval(decl.sourceInterval(78, 91))) .define("Formals", [], this.seq(this.prim("(").withInterval(decl.sourceInterval(109, 112)), this.app("ListOf", [this.app("name").withInterval(decl.sourceInterval(120, 124)), this.prim(",").withInterval(decl.sourceInterval(126, 129))]).withInterval(decl.sourceInterval(113, 130)), this.prim(")").withInterval(decl.sourceInterval(131, 134))).withInterval(decl.sourceInterval(109, 134))) .define("name", [], this.seq(this.app("nameFirst").withInterval(decl.sourceInterval(159, 168)), this.star(this.app("nameRest").withInterval(decl.sourceInterval(169, 177))).withInterval(decl.sourceInterval(169, 178))).withInterval(decl.sourceInterval(159, 178)), "a name") .define("nameFirst", [], this.alt(this.prim("_").withInterval(decl.sourceInterval(198, 201)), this.app("letter").withInterval(decl.sourceInterval(208, 214))).withInterval(decl.sourceInterval(198, 214))) .define("nameRest", [], this.alt(this.prim("_").withInterval(decl.sourceInterval(233, 236)), this.app("alnum").withInterval(decl.sourceInterval(243, 248))).withInterval(decl.sourceInterval(233, 248))) .build(); }); },{"..":50}],13:[function(require,module,exports){ 'use strict'; module.exports = { toAST: require('./semantics-toAST').helper, semanticsForToAST: require('./semantics-toAST').semantics }; },{"./semantics-toAST":14}],14:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var pexprs = require('../src/pexprs'); var MatchResult = require('../src/MatchResult'); var Grammar = require('../src/Grammar'); var extend = require('util-extend'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- var defaultOperation = { _nonterminal: function(children) { var ctorName = this._node.ctorName; var mapping = this.args.mapping; // without customization if (!mapping.hasOwnProperty(ctorName)) { // intermediate node if (this._node instanceof pexprs.Alt || this._node instanceof pexprs.Apply) { return children[0].toAST(mapping); } // lexical rule if (this.isLexical()) { return this.interval.contents; } // singular node (e.g. only surrounded by literals or lookaheads) var realChildren = children.filter(function(child) { return !child.isTerminal(); }); if (realChildren.length === 1) { return realChildren[0].toAST(mapping); } // rest: terms with multiple children } // direct forward if (typeof mapping[ctorName] === 'number') { return children[mapping[ctorName]].toAST(mapping); } // named/mapped children or unnamed children ('0', '1', '2', ...) var propMap = mapping[ctorName] || children; var node = { type: ctorName }; for (var prop in propMap) { var mappedProp = mapping[ctorName] && mapping[ctorName][prop]; if (typeof mappedProp === 'number') { // direct forward node[prop] = children[mappedProp].toAST(mapping); } else if ((typeof mappedProp === 'string') || (typeof mappedProp === 'boolean') || (mappedProp === null)) { // primitive value node[prop] = mappedProp; } else if ((typeof mappedProp === 'object') && (mappedProp instanceof Number)) { // primitive number (must be unboxed) node[prop] = Number(mappedProp); } else if (typeof mappedProp === 'function') { // computed value node[prop] = mappedProp.call(this, children); } else if (mappedProp === undefined) { if (children[prop] && !children[prop].isTerminal()) { node[prop] = children[prop].toAST(mapping); } else { // delete predefined 'type' properties, like 'type', if explicitely removed delete node[prop]; } } } return node; }, _iter: function(children) { if (this._node.isOptional()) { if (this.numChildren === 0) { return null; } else { return children[0].toAST(this.args.mapping); } } return children.map(function(child) { return child.toAST(this.args.mapping); }, this); }, NonemptyListOf: function(first, sep, rest) { return [first.toAST(this.args.mapping)].concat(rest.toAST(this.args.mapping)); }, EmptyListOf: function() { return []; } }; // Returns a plain JavaScript object that includes an abstract syntax tree (AST) // for the given match result `res` containg a concrete syntax tree (CST) and grammar. // The optional `mapping` parameter can be used to customize how the nodes of the CST // are mapped to the AST (see /doc/extras.md#toastmatchresult-mapping). function toAST(res, mapping) { if (!(res instanceof MatchResult) || res.failed()) { throw new Error('toAST() expects a succesfull MatchResult as first parameter'); } mapping = extend({}, mapping); var operation = extend({}, defaultOperation); for (var termName in mapping) { if (typeof mapping[termName] === 'function') { operation[termName] = mapping[termName]; delete mapping[termName]; } } var g = res._cst.grammar; var s = g.semantics().addOperation('toAST(mapping)', operation); return s(res).toAST(mapping); } // Returns a semantics containg the toAST(mapping) operation for the given grammar g. function semanticsForToAST(g) { if (!(g instanceof Grammar)) { throw new Error('semanticsToAST() expects a Grammar as parameter'); } return g.semantics().addOperation('toAST(mapping)', defaultOperation); } module.exports = { helper: toAST, semantics: semanticsForToAST }; },{"../src/Grammar":38,"../src/MatchResult":42,"../src/pexprs":67,"util-extend":35}],15:[function(require,module,exports){ 'use strict'; module.exports = require('./is-implemented')() ? Symbol : require('./polyfill'); },{"./is-implemented":16,"./polyfill":31}],16:[function(require,module,exports){ 'use strict'; module.exports = function () { var symbol; if (typeof Symbol !== 'function') return false; symbol = Symbol('test symbol'); try { String(symbol); } catch (e) { return false; } if (typeof Symbol.iterator === 'symbol') return true; // Return 'true' for polyfills if (typeof Symbol.isConcatSpreadable !== 'object') return false; if (typeof Symbol.iterator !== 'object') return false; if (typeof Symbol.toPrimitive !== 'object') return false; if (typeof Symbol.toStringTag !== 'object') return false; if (typeof Symbol.unscopables !== 'object') return false; return true; }; },{}],17:[function(require,module,exports){ 'use strict'; module.exports = function (x) { return (x && ((typeof x === 'symbol') || (x['@@toStringTag'] === 'Symbol'))) || false; }; },{}],18:[function(require,module,exports){ 'use strict'; var assign = require('es5-ext/object/assign') , normalizeOpts = require('es5-ext/object/normalize-options') , isCallable = require('es5-ext/object/is-callable') , contains = require('es5-ext/string/#/contains') , d; d = module.exports = function (dscr, value/*, options*/) { var c, e, w, options, desc; if ((arguments.length < 2) || (typeof dscr !== 'string')) { options = value; value = dscr; dscr = null; } else { options = arguments[2]; } if (dscr == null) { c = w = true; e = false; } else { c = contains.call(dscr, 'c'); e = contains.call(dscr, 'e'); w = contains.call(dscr, 'w'); } desc = { value: value, configurable: c, enumerable: e, writable: w }; return !options ? desc : assign(normalizeOpts(options), desc); }; d.gs = function (dscr, get, set/*, options*/) { var c, e, options, desc; if (typeof dscr !== 'string') { options = set; set = get; get = dscr; dscr = null; } else { options = arguments[3]; } if (get == null) { get = undefined; } else if (!isCallable(get)) { options = get; get = set = undefined; } else if (set == null) { set = undefined; } else if (!isCallable(set)) { options = set; set = undefined; } if (dscr == null) { c = true; e = false; } else { c = contains.call(dscr, 'c'); e = contains.call(dscr, 'e'); } desc = { get: get, set: set, configurable: c, enumerable: e }; return !options ? desc : assign(normalizeOpts(options), desc); }; },{"es5-ext/object/assign":19,"es5-ext/object/is-callable":22,"es5-ext/object/normalize-options":26,"es5-ext/string/#/contains":28}],19:[function(require,module,exports){ 'use strict'; module.exports = require('./is-implemented')() ? Object.assign : require('./shim'); },{"./is-implemented":20,"./shim":21}],20:[function(require,module,exports){ 'use strict'; module.exports = function () { var assign = Object.assign, obj; if (typeof assign !== 'function') return false; obj = { foo: 'raz' }; assign(obj, { bar: 'dwa' }, { trzy: 'trzy' }); return (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy'; }; },{}],21:[function(require,module,exports){ 'use strict'; var keys = require('../keys') , value = require('../valid-value') , max = Math.max; module.exports = function (dest, src/*, …srcn*/) { var error, i, l = max(arguments.length, 2), assign; dest = Object(value(dest)); assign = function (key) { try { dest[key] = src[key]; } catch (e) { if (!error) error = e; } }; for (i = 1; i < l; ++i) { src = arguments[i]; keys(src).forEach(assign); } if (error !== undefined) throw error; return dest; }; },{"../keys":23,"../valid-value":27}],22:[function(require,module,exports){ // Deprecated 'use strict'; module.exports = function (obj) { return typeof obj === 'function'; }; },{}],23:[function(require,module,exports){ 'use strict'; module.exports = require('./is-implemented')() ? Object.keys : require('./shim'); },{"./is-implemented":24,"./shim":25}],24:[function(require,module,exports){ 'use strict'; module.exports = function () { try { Object.keys('primitive'); return true; } catch (e) { return false; } }; },{}],25:[function(require,module,exports){ 'use strict'; var keys = Object.keys; module.exports = function (object) { return keys(object == null ? object : Object(object)); }; },{}],26:[function(require,module,exports){ 'use strict'; var forEach = Array.prototype.forEach, create = Object.create; var process = function (src, obj) { var key; for (key in src) obj[key] = src[key]; }; module.exports = function (options/*, …options*/) { var result = create(null); forEach.call(arguments, function (options) { if (options == null) return; process(Object(options), result); }); return result; }; },{}],27:[function(require,module,exports){ 'use strict'; module.exports = function (value) { if (value == null) throw new TypeError("Cannot use null or undefined"); return value; }; },{}],28:[function(require,module,exports){ 'use strict'; module.exports = require('./is-implemented')() ? String.prototype.contains : require('./shim'); },{"./is-implemented":29,"./shim":30}],29:[function(require,module,exports){ 'use strict'; var str = 'razdwatrzy'; module.exports = function () { if (typeof str.contains !== 'function') return false; return ((str.contains('dwa') === true) && (str.contains('foo') === false)); }; },{}],30:[function(require,module,exports){ 'use strict'; var indexOf = String.prototype.indexOf; module.exports = function (searchString/*, position*/) { return indexOf.call(this, searchString, arguments[1]) > -1; }; },{}],31:[function(require,module,exports){ 'use strict'; var d = require('d') , validateSymbol = require('./validate-symbol') , create = Object.create, defineProperties = Object.defineProperties , defineProperty = Object.defineProperty, objPrototype = Object.prototype , Symbol, HiddenSymbol, globalSymbols = create(null); var generateName = (function () { var created = create(null); return function (desc) { var postfix = 0, name; while (created[desc + (postfix || '')]) ++postfix; desc += (postfix || ''); created[desc] = true; name = '@@' + desc; defineProperty(objPrototype, name, d.gs(null, function (value) { defineProperty(this, name, d(value)); })); return name; }; }()); HiddenSymbol = function Symbol(description) { if (this instanceof HiddenSymbol) throw new TypeError('TypeError: Symbol is not a constructor'); return Symbol(description); }; module.exports = Symbol = function Symbol(description) { var symbol; if (this instanceof Symbol) throw new TypeError('TypeError: Symbol is not a constructor'); symbol = create(HiddenSymbol.prototype); description = (description === undefined ? '' : String(description)); return defineProperties(symbol, { __description__: d('', description), __name__: d('', generateName(description)) }); }; defineProperties(Symbol, { for: d(function (key) { if (globalSymbols[key]) return globalSymbols[key]; return (globalSymbols[key] = Symbol(String(key))); }), keyFor: d(function (s) { var key; validateSymbol(s); for (key in globalSymbols) if (globalSymbols[key] === s) return key; }), hasInstance: d('', Symbol('hasInstance')), isConcatSpreadable: d('', Symbol('isConcatSpreadable')), iterator: d('', Symbol('iterator')), match: d('', Symbol('match')), replace: d('', Symbol('replace')), search: d('', Symbol('search')), species: d('', Symbol('species')), split: d('', Symbol('split')), toPrimitive: d('', Symbol('toPrimitive')), toStringTag: d('', Symbol('toStringTag')), unscopables: d('', Symbol('unscopables')) }); defineProperties(HiddenSymbol.prototype, { constructor: d(Symbol), toString: d('', function () { return this.__name__; }) }); defineProperties(Symbol.prototype, { toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }), valueOf: d(function () { return validateSymbol(this); }) }); defineProperty(Symbol.prototype, Symbol.toPrimitive, d('', function () { return validateSymbol(this); })); defineProperty(Symbol.prototype, Symbol.toStringTag, d('c', 'Symbol')); defineProperty(HiddenSymbol.prototype, Symbol.toPrimitive, d('c', Symbol.prototype[Symbol.toPrimitive])); defineProperty(HiddenSymbol.prototype, Symbol.toStringTag, d('c', Symbol.prototype[Symbol.toStringTag])); },{"./validate-symbol":32,"d":18}],32:[function(require,module,exports){ 'use strict'; var isSymbol = require('./is-symbol'); module.exports = function (value) { if (!isSymbol(value)) throw new TypeError(value + " is not a symbol"); return value; }; },{"./is-symbol":17}],33:[function(require,module,exports){ if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor ctor.prototype = Object.create(superCtor.prototype, { constructor: { value: ctor, enumerable: false, writable: true, configurable: true } }); }; } else { // old school shim for old browsers module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor var TempCtor = function () {} TempCtor.prototype = superCtor.prototype ctor.prototype = new TempCtor() ctor.prototype.constructor = ctor } } },{}],34:[function(require,module,exports){ /** * Determine if an object is Buffer * * Author: Feross Aboukhadijeh * License: MIT * * `npm install is-buffer` */ module.exports = function (obj) { return !!( obj != null && obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) ) } },{}],35:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. module.exports = extend; function extend(origin, add) { // Don't do anything if add isn't an object if (!add || typeof add !== 'object') return origin; var keys = Object.keys(add); var i = keys.length; while (i--) { origin[keys[i]] = add[keys[i]]; } return origin; } },{}],36:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var GrammarDecl = require('./GrammarDecl'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function Builder() {} Builder.prototype = { newGrammar: function(name) { return new GrammarDecl(name); }, prim: function(x) { return new pexprs.Prim(x); }, range: function(from, to) { return new pexprs.Range(from, to); }, param: function(index) { return new pexprs.Param(index); }, alt: function(/* term1, term1, ... */) { var terms = []; for (var idx = 0; idx < arguments.length; idx++) { var arg = arguments[idx]; if (arg instanceof pexprs.Alt) { terms = terms.concat(arg.terms); } else { terms.push(arg); } } return terms.length === 1 ? terms[0] : new pexprs.Alt(terms); }, seq: function(/* factor1, factor2, ... */) { var factors = []; for (var idx = 0; idx < arguments.length; idx++) { var arg = arguments[idx]; if (arg instanceof pexprs.Seq) { factors = factors.concat(arg.factors); } else { factors.push(arg); } } return factors.length === 1 ? factors[0] : new pexprs.Seq(factors); }, star: function(expr) { return new pexprs.Star(expr); }, plus: function(expr) { return new pexprs.Plus(expr); }, opt: function(expr) { return new pexprs.Opt(expr); }, not: function(expr) { return new pexprs.Not(expr); }, la: function(expr) { return new pexprs.Lookahead(expr); }, lex: function(expr) { return new pexprs.Lex(expr); }, val: function(expr) { return new pexprs.Value(expr); }, arr: function(expr) { return new pexprs.Arr(expr); }, str: function(expr) { return new pexprs.Str(expr); }, obj: function(properties, isLenient) { return new pexprs.Obj(properties, !!isLenient); }, app: function(ruleName, optParams) { return new pexprs.Apply(ruleName, optParams); } }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Builder; },{"./GrammarDecl":39,"./pexprs":67}],37:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- /* `Failure`s represent expressions that weren't matched while parsing. They are used to generate error messages automatically. The interface of `Failure`s includes the collowing methods: - getText() : String - getType() : String (one of {"description", "string", "code"}) - isDescription() : bool - isStringTerminal() : bool - isCode() : bool - isFluffy() : bool - makeFluffy() : void - subsumes(Failure) : bool */ function isValidType(type) { return type === 'description' || type === 'string' || type === 'code'; } function Failure(text, type) { if (!isValidType(type)) { throw new Error('invalid Failure type: ' + type); } this.text = text; this.type = type; this.fluffy = false; } Failure.prototype.getText = function() { return this.text; }; Failure.prototype.getType = function() { return this.type; }; Failure.prototype.isDescription = function() { return this.type === 'description'; }; Failure.prototype.isStringTerminal = function() { return this.type === 'string'; }; Failure.prototype.isCode = function() { return this.type === 'code'; }; Failure.prototype.isFluffy = function() { return this.fluffy; }; Failure.prototype.makeFluffy = function() { this.fluffy = true; }; Failure.prototype.clearFluffy = function() { this.fluffy = false; }; Failure.prototype.subsumes = function(that) { return this.getText() === that.getText() && this.type === that.type && (!this.isFluffy() || this.isFluffy() && that.isFluffy()); }; Failure.prototype.toString = function() { return this.type === 'string' ? JSON.stringify(this.getText()) : this.getText(); }; Failure.prototype.clone = function() { var failure = new Failure(this.text, this.type); if (this.isFluffy()) { failure.makeFluffy(); } return failure; }; Failure.prototype.toKey = function() { return this.toString() + '#' + this.type; }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Failure; },{}],38:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var MatchResult = require('./MatchResult'); var Semantics = require('./Semantics'); var State = require('./State'); var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function Grammar( name, superGrammar, ruleBodies, ruleFormals, ruleDescriptions, optDefaultStartRule) { this.name = name; this.superGrammar = superGrammar; this.ruleBodies = ruleBodies; this.ruleFormals = ruleFormals; this.ruleDescriptions = ruleDescriptions; if (optDefaultStartRule) { if (!(optDefaultStartRule in ruleBodies)) { throw new Error("Invalid start rule: '" + optDefaultStartRule + "' is not a rule in grammar '" + name + "'"); } this.defaultStartRule = optDefaultStartRule; } this.constructors = this.ctors = this.createConstructors(); } var ohmGrammar; var buildGrammar; // This method is called from main.js once Ohm has loaded. Grammar.initStartRuleParser = function(grammar, builderFn) { ohmGrammar = grammar; buildGrammar = builderFn; }; Grammar.prototype = { construct: function(ruleName, children) { var body = this.ruleBodies[ruleName]; if (!body) { throw errors.undeclaredRule(ruleName, this.name); } var ans = this._constructByMatching(ruleName, children); if (!ans) { throw errors.invalidConstructorCall(this, ruleName, children); } return ans; }, // Try to match `ctorArgs` with the body of the rule given by `ruleName`. // Return the resulting CST node if it succeeds, otherwise return null. _constructByMatching: function(ruleName, ctorArgs) { var state = this._match(ctorArgs, ruleName, {matchNodes: true}); if (state.bindings.length === 1) { return state.bindings[0]; } return null; }, createConstructors: function() { var self = this; var constructors = {}; function makeConstructor(ruleName) { return function(/* val1, val2, ... */) { return self.construct(ruleName, Array.prototype.slice.call(arguments)); }; } for (var ruleName in this.ruleBodies) { // We want *all* properties, not just own properties, because of // supergrammars. constructors[ruleName] = makeConstructor(ruleName); } return constructors; }, // Return true if the grammar is a built-in grammar, otherwise false. // NOTE: This might give an unexpected result if called before BuiltInRules is defined! isBuiltIn: function() { return this === Grammar.ProtoBuiltInRules || this === Grammar.BuiltInRules; }, match: function(obj, optStartApplication) { var startApplication = optStartApplication || this.defaultStartRule; if (!startApplication) { throw new Error('Missing start rule argument -- the grammar has no default start rule.'); } var state = this._match([obj], startApplication, {}); return MatchResult.newFor(state); }, _match: function(values, startApplication, opts) { var expr; if (startApplication.indexOf('<') === -1) { // do not run in circles // simple application expr = new pexprs.Apply(startApplication); } else { // parameterized application var cst = ohmGrammar.match(startApplication, 'Base_application'); expr = buildGrammar(cst, {}); } var startRule = expr.ruleName; if (!(startRule in this.ruleBodies)) { throw errors.undeclaredRule(startRule, this.name); } else if (this.ruleFormals[startRule].length !== expr.args.length) { throw errors.wrongNumberOfParameters(startRule, this.ruleFormals[startRule].length, expr.args.length); } var state = new State(this, expr.newInputStreamFor(values, this), startRule, opts); state.eval(expr); return state; }, trace: function(obj, optStartRule) { var startRule = optStartRule || this.defaultStartRule; if (!startRule) { throw new Error('Missing start rule argument -- the grammar has no default start rule.'); } var state = this._match([obj], startRule, {trace: true}); var rootTrace = state.trace[0]; rootTrace.state = state; rootTrace.result = MatchResult.newFor(state); return rootTrace; }, semantics: function() { return Semantics.createSemantics(this); }, extendSemantics: function(superSemantics) { return Semantics.createSemantics(this, superSemantics._getSemantics()); }, // Check that every key in `actionDict` corresponds to a semantic action, and that it maps to // a function of the correct arity. If not, throw an exception. _checkTopDownActionDict: function(what, name, actionDict) { function isSpecialAction(a) { return a === '_iter' || a === '_terminal' || a === '_nonterminal' || a === '_default'; } var problems = []; for (var k in actionDict) { var v = actionDict[k]; if (!isSpecialAction(k) && !(k in this.ruleBodies)) { problems.push("'" + k + "' is not a valid semantic action for '" + this.name + "'"); } else if (typeof v !== 'function') { problems.push( "'" + k + "' must be a function in an action dictionary for '" + this.name + "'"); } else { var actual = v.length; var expected = this._topDownActionArity(k); if (actual !== expected) { problems.push( "Semantic action '" + k + "' has the wrong arity: " + 'expected ' + expected + ', got ' + actual); } } } if (problems.length > 0) { var prettyProblems = problems.map(function(problem) { return '- ' + problem; }); var error = new Error( "Found errors in the action dictionary of the '" + name + "' " + what + ':\n' + prettyProblems.join('\n')); error.problems = problems; throw error; } }, // Return the expected arity for a semantic action named `actionName`, which // is either a rule name or a special action name like '_nonterminal'. _topDownActionArity: function(actionName) { if (actionName === '_iter' || actionName === '_nonterminal' || actionName === '_default') { return 1; } else if (actionName === '_terminal') { return 0; } return this.ruleBodies[actionName].getArity(); }, _inheritsFrom: function(grammar) { var g = this.superGrammar; while (g) { if (g === grammar) { return true; } g = g.superGrammar; } return false; }, toRecipe: function(optVarName) { if (this.isBuiltIn()) { throw new Error( 'Why would anyone want to generate a recipe for the ' + this.name + ' grammar?!?!'); } var sb = new common.StringBuffer(); if (optVarName) { sb.append('var ' + optVarName + ' = '); } sb.append('(function() {\n'); // Include the supergrammar in the recipe if it's not a built-in grammar. var superGrammarDecl = ''; if (!this.superGrammar.isBuiltIn()) { sb.append(this.superGrammar.toRecipe('buildSuperGrammar')); superGrammarDecl = ' .withSuperGrammar(buildSuperGrammar.call(this))\n'; } sb.append(' var decl = this.newGrammar(' + JSON.stringify(this.name) + ')\n'); // Include the grammar source if it is available. if (this.definitionInterval) { sb.append(' .withSource(' + JSON.stringify(this.definitionInterval.contents) + ')\n'); } sb.append(superGrammarDecl); if (this.defaultStartRule) { sb.append(' .withDefaultStartRule("' + this.defaultStartRule + '")\n'); } sb.append(' return decl\n'); var self = this; Object.keys(this.ruleBodies).forEach(function(ruleName) { var body = self.ruleBodies[ruleName]; sb.append(' .'); if (self.superGrammar.ruleBodies[ruleName]) { sb.append(body instanceof pexprs.Extend ? 'extend' : 'override'); } else { sb.append('define'); } var formals = self.ruleFormals[ruleName]; var formalsString = '[' + formals.map(JSON.stringify).join(', ') + ']'; sb.append('(' + JSON.stringify(ruleName) + ', ' + formalsString + ', '); body.outputRecipe(sb, formals, self.definitionInterval); if (!self.superGrammar.ruleBodies[ruleName] && self.ruleDescriptions[ruleName]) { sb.append(', ' + JSON.stringify(self.ruleDescriptions[ruleName])); } sb.append(')\n'); }); sb.append(' .build();\n});\n'); return sb.contents(); }, // TODO: Come up with better names for these methods. // TODO: Write the analog of these methods for inherited attributes. toOperationActionDictionaryTemplate: function() { return this._toOperationOrAttributeActionDictionaryTemplate(); }, toAttributeActionDictionaryTemplate: function() { return this._toOperationOrAttributeActionDictionaryTemplate(); }, _toOperationOrAttributeActionDictionaryTemplate: function() { // TODO: add the super-grammar's templates at the right place, e.g., a case for AddExpr_plus // should appear next to other cases of AddExpr. var sb = new common.StringBuffer(); sb.append('{'); var first = true; for (var ruleName in this.ruleBodies) { var body = this.ruleBodies[ruleName]; if (first) { first = false; } else { sb.append(','); } sb.append('\n'); sb.append(' '); this.addSemanticActionTemplate(ruleName, body, sb); } sb.append('\n}'); return sb.contents(); }, addSemanticActionTemplate: function(ruleName, body, sb) { sb.append(ruleName); sb.append(': function('); var arity = this._topDownActionArity(ruleName); sb.append(common.repeat('_', arity).join(', ')); sb.append(') {\n'); sb.append(' }'); } }; // The following grammar contains a few rules that couldn't be written in "userland". // At the bottom of src/main.js, we create a sub-grammar of this grammar that's called // `BuiltInRules`. That grammar contains several convenience rules, e.g., `letter` and // `digit`, and is implicitly the super-grammar of any grammar whose super-grammar // isn't specified. Grammar.ProtoBuiltInRules = new Grammar( 'ProtoBuiltInRules', // name undefined, // supergrammar // rule bodies { any: pexprs.any, end: pexprs.end, lower: new pexprs.UnicodeChar('Ll'), // The following rule is invoked implicitly by syntactic rules to skip spaces. spaces: new pexprs.Star(new pexprs.Apply('space')), // The `space` rule must be defined here because it's referenced by `spaces`. space: new pexprs.Range('\x00', ' '), // The union of Lt (titlecase), Lm (modifier), and Lo (other), i.e. any letter not // in Ll or Lu. unicodeLtmo: new pexprs.UnicodeChar('Ltmo'), upper: new pexprs.UnicodeChar('Lu'), Boolean: new pexprs.TypeCheck('boolean'), Number: new pexprs.TypeCheck('number'), String: new pexprs.TypeCheck('string') }, // rule formal arguments { any: [], end: [], spaces: [], space: [], lower: [], unicodeLtmo: [], upper: [], Boolean: [], Number: [], String: [] }, // rule descriptions { any: 'any object', end: 'end of input', space: 'a space', lower: 'a lowercase letter', upper: 'an uppercase letter' } ); // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Grammar; },{"./MatchResult":42,"./Semantics":45,"./State":46,"./common":48,"./errors":49,"./pexprs":67}],39:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var Grammar = require('./Grammar'); var InputStream = require('./InputStream'); var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Private Stuff // -------------------------------------------------------------------- // Constructors function GrammarDecl(name) { this.name = name; } // Helpers GrammarDecl.prototype.sourceInterval = function(startIdx, endIdx) { var inputStream = this.interval.inputStream; return inputStream.interval(startIdx, endIdx); }; GrammarDecl.prototype.ensureSuperGrammar = function() { if (!this.superGrammar) { this.withSuperGrammar( // TODO: The conditional expression below is an ugly hack. It's kind of ok because // I doubt anyone will ever try to declare a grammar called `BuiltInRules`. Still, // we should try to find a better way to do this. this.name === 'BuiltInRules' ? Grammar.ProtoBuiltInRules : Grammar.BuiltInRules); } return this.superGrammar; }; GrammarDecl.prototype.installOverriddenOrExtendedRule = function(name, formals, body) { var duplicateParameterNames = common.getDuplicates(formals); if (duplicateParameterNames.length > 0) { throw errors.duplicateParameterNames(name, duplicateParameterNames, body); } var expectedFormals = this.ensureSuperGrammar().ruleFormals[name]; var expectedNumFormals = expectedFormals ? expectedFormals.length : 0; if (formals.length !== expectedNumFormals) { throw errors.wrongNumberOfParameters(name, expectedNumFormals, formals.length, body); } return this.install(name, formals, body); }; GrammarDecl.prototype.install = function(name, formals, body, optDescription) { body = body.introduceParams(formals); this.ruleFormals[name] = formals; if (optDescription) { this.ruleDescriptions[name] = optDescription; } this.ruleBodies[name] = body; return this; }; // Stuff that you should only do once GrammarDecl.prototype.withSuperGrammar = function(superGrammar) { if (this.superGrammar) { throw new Error('the super grammar of a GrammarDecl cannot be set more than once'); } this.superGrammar = superGrammar; this.ruleBodies = Object.create(superGrammar.ruleBodies); this.ruleFormals = Object.create(superGrammar.ruleFormals); this.ruleDescriptions = Object.create(superGrammar.ruleDescriptions); // Grammars with an explicit supergrammar inherit a default start rule. if (!superGrammar.isBuiltIn()) { this.defaultStartRule = superGrammar.defaultStartRule; } return this; }; GrammarDecl.prototype.withDefaultStartRule = function(ruleName) { this.defaultStartRule = ruleName; return this; }; GrammarDecl.prototype.withSource = function(source) { this.interval = InputStream.newFor(source).interval(0, source.length); return this; }; // Creates a Grammar instance, and if it passes the sanity checks, returns it. GrammarDecl.prototype.build = function() { var grammar = new Grammar( this.name, this.ensureSuperGrammar(), this.ruleBodies, this.ruleFormals, this.ruleDescriptions, this.defaultStartRule); // TODO: change the pexpr.prototype.assert... methods to make them add // exceptions to an array that's provided as an arg. Then we'll be able to // show more than one error of the same type at a time. // TODO: include the offending pexpr in the errors, that way we can show // the part of the source that caused it. var grammarErrors = []; var grammarHasInvalidApplications = false; Object.keys(grammar.ruleBodies).forEach(function(ruleName) { var body = grammar.ruleBodies[ruleName]; try { body.assertChoicesHaveUniformArity(ruleName); } catch (e) { grammarErrors.push(e); } try { body.assertAllApplicationsAreValid(ruleName, grammar); } catch (e) { grammarErrors.push(e); grammarHasInvalidApplications = true; } }); if (!grammarHasInvalidApplications) { // The following check can only be done if the grammar has no invalid applications. Object.keys(grammar.ruleBodies).forEach(function(ruleName) { var body = grammar.ruleBodies[ruleName]; try { body.assertIteratedExprsAreNotNullable(grammar, ruleName); } catch (e) { grammarErrors.push(e); } // For now, only check the bodies of unparameterized rules, because the checks can't deal // properly with parameters that don't have a concrete value. // TODO: Fix this. if (grammar.ruleFormals[ruleName].length === 0) { try { body.assertValuesAndStringsAreNotMixed(grammar, ruleName); } catch (e) { grammarErrors.push(e); } } }); } if (grammarErrors.length > 0) { errors.throwErrors(grammarErrors); } if (this.interval) { grammar.definitionInterval = this.interval; } return grammar; }; // Rule declarations GrammarDecl.prototype.define = function(name, formals, body, optDescr) { this.ensureSuperGrammar(); if (this.superGrammar.ruleBodies[name]) { throw errors.duplicateRuleDeclaration(name, this.name, this.superGrammar.name, body); } else if (this.ruleBodies[name]) { throw errors.duplicateRuleDeclaration(name, this.name, this.name, body); } var duplicateParameterNames = common.getDuplicates(formals); if (duplicateParameterNames.length > 0) { throw errors.duplicateParameterNames(name, duplicateParameterNames, body); } return this.install(name, formals, body, optDescr); }; GrammarDecl.prototype.override = function(name, formals, body) { var baseRule = this.ensureSuperGrammar().ruleBodies[name]; if (!baseRule) { throw errors.cannotOverrideUndeclaredRule(name, this.superGrammar.name, body); } this.installOverriddenOrExtendedRule(name, formals, body); return this; }; GrammarDecl.prototype.extend = function(name, formals, fragment) { var baseRule = this.ensureSuperGrammar().ruleBodies[name]; if (!baseRule) { throw errors.cannotExtendUndeclaredRule(name, this.superGrammar.name, fragment); } var body = new pexprs.Extend(this.superGrammar, name, fragment); body.interval = fragment.interval; this.installOverriddenOrExtendedRule(name, formals, body); return this; }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = GrammarDecl; },{"./Grammar":38,"./InputStream":40,"./common":48,"./errors":49,"./pexprs":67}],40:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var inherits = require('inherits'); var common = require('./common'); var Interval = require('./Interval'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function InputStream() { throw new Error('InputStream cannot be instantiated -- it\'s abstract'); } InputStream.newFor = function(arrOrStr) { return Array.isArray(arrOrStr) ? new ListInputStream(arrOrStr) : new StringInputStream(arrOrStr); }; InputStream.prototype = { init: function(source) { this.source = source; this.pos = 0; this.posInfos = []; }, atEnd: function() { return this.pos === this.source.length; }, next: function() { if (this.atEnd()) { return common.fail; } else { return this.source[this.pos++]; } }, matchExactly: function(x) { return this.next() === x ? true : common.fail; }, sourceSlice: function(startIdx, endIdx) { return this.source.slice(startIdx, endIdx); }, interval: function(startIdx, optEndIdx) { return new Interval(this, startIdx, optEndIdx ? optEndIdx : this.pos); } }; function StringInputStream(source) { this.init(source); } inherits(StringInputStream, InputStream); StringInputStream.prototype.matchString = function(s) { for (var idx = 0; idx < s.length; idx++) { if (this.matchExactly(s[idx]) === common.fail) { return common.fail; } } return true; }; function ListInputStream(source) { this.init(source); } inherits(ListInputStream, InputStream); ListInputStream.prototype.matchString = function(s) { return this.matchExactly(s); }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = InputStream; },{"./Interval":41,"./common":48,"inherits":33}],41:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var assert = require('./common').assert; var errors = require('./errors'); var util = require('./util'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function Interval(inputStream, startIdx, endIdx) { this.inputStream = inputStream; this.startIdx = startIdx; this.endIdx = endIdx; } Interval.coverage = function(/* interval1, interval2, ... */) { var inputStream = arguments[0].inputStream; var startIdx = arguments[0].startIdx; var endIdx = arguments[0].endIdx; for (var idx = 1; idx < arguments.length; idx++) { var interval = arguments[idx]; if (interval.inputStream !== inputStream) { throw errors.intervalSourcesDontMatch(); } else { startIdx = Math.min(startIdx, arguments[idx].startIdx); endIdx = Math.max(endIdx, arguments[idx].endIdx); } } return new Interval(inputStream, startIdx, endIdx); }; Interval.prototype = { coverageWith: function(/* interval1, interval2, ... */) { var intervals = Array.prototype.slice.call(arguments); intervals.push(this); return Interval.coverage.apply(undefined, intervals); }, collapsedLeft: function() { return new Interval(this.inputStream, this.startIdx, this.startIdx); }, collapsedRight: function() { return new Interval(this.inputStream, this.endIdx, this.endIdx); }, getLineAndColumnMessage: function() { var range = [this.startIdx, this.endIdx]; return util.getLineAndColumnMessage(this.inputStream.source, this.startIdx, range); }, // Returns an array of 0, 1, or 2 intervals that represents the result of the // interval difference operation. minus: function(that) { if (this.inputStream !== that.inputStream) { throw errors.intervalSourcesDontMatch(); } else if (this.startIdx === that.startIdx && this.endIdx === that.endIdx) { // `this` and `that` are the same interval! return [ ]; } else if (this.startIdx < that.startIdx && that.endIdx < this.endIdx) { // `that` splits `this` into two intervals return [ new Interval(this.inputStream, this.startIdx, that.startIdx), new Interval(this.inputStream, that.endIdx, this.endIdx) ]; } else if (this.startIdx < that.endIdx && that.endIdx < this.endIdx) { // `that` contains a prefix of `this` return [ new Interval(this.inputStream, that.endIdx, this.endIdx) ]; } else if (this.startIdx < that.startIdx && that.startIdx < this.endIdx) { // `that` contains a suffix of `this` return [ new Interval(this.inputStream, this.startIdx, that.startIdx) ]; } else { // `that` and `this` do not overlap return [ this ]; } }, // Returns a new Interval that has the same extent as this one, but which is relative // to `that`, an Interval that fully covers this one. relativeTo: function(that, newInputStream) { if (this.inputStream !== that.inputStream) { throw errors.intervalSourcesDontMatch(); } assert(this.startIdx >= that.startIdx && this.endIdx <= that.endIdx, 'other interval does not cover this one'); return new Interval(newInputStream, this.startIdx - that.startIdx, this.endIdx - that.startIdx); }, // Returns a new Interval which contains the same contents as this one, // but with whitespace trimmed from both ends. (This only makes sense when // the input stream is a string.) trimmed: function() { var contents = this.contents; var startIdx = this.startIdx + contents.match(/^\s*/)[0].length; var endIdx = this.endIdx - contents.match(/\s*$/)[0].length; return new Interval(this.inputStream, startIdx, endIdx); } }; Object.defineProperties(Interval.prototype, { contents: { get: function() { if (this._contents === undefined) { this._contents = this.inputStream.sourceSlice(this.startIdx, this.endIdx); } return this._contents; }, enumerable: true } }); // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Interval; },{"./common":48,"./errors":49,"./util":68}],42:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var inherits = require('inherits'); var common = require('./common'); var nodes = require('./nodes'); var util = require('./util'); var Interval = require('./Interval'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- // Create a short error message for an error that occurred during matching. function getShortMatchErrorMessage(pos, source, detail) { var errorInfo = util.getLineAndColumn(source, pos); return 'Line ' + errorInfo.lineNum + ', col ' + errorInfo.colNum + ': ' + detail; } // ----------------- MatchFailure ----------------- function MatchResult(state) { this.state = state; this._cst = state.bindings[0]; } MatchResult.newFor = function(state) { var succeeded = state.bindings.length === 1; return succeeded ? new MatchResult(state) : new MatchFailure(state); }; MatchResult.prototype.failed = function() { return false; }; MatchResult.prototype.succeeded = function() { return !this.failed(); }; // Returns a `MatchResult` that can be fed into operations or attributes that care // about the whitespace that was implicitly skipped over by syntactic rules. This // is useful for doing things with comments, e.g., syntax highlighting. MatchResult.prototype.getDiscardedSpaces = function() { if (this.failed()) { return []; } var state = this.state; var grammar = state.grammar; var inputStream = state.inputStream; var intervals = [new Interval(inputStream, 0, inputStream.source.length)]; // Subtract the interval of each terminal from the set of intervals above. var s = grammar.semantics().addOperation('subtractTerminals', { _nonterminal: function(children) { children.forEach(function(child) { child.subtractTerminals(); }); }, _terminal: function() { var t = this; intervals = intervals. map(function(interval) { return interval.minus(t.interval); }). reduce(function(xs, ys) { return xs.concat(ys); }, []); } }); s(this).subtractTerminals(); // Now `intervals` holds the intervals of the input stream that were skipped over by syntactic // rules, because they contained spaces. // Next, we want to match the contents of each of those intervals with the grammar's `spaces` // rule, to reconstruct the CST nodes that were discarded by syntactic rules. But if we simply // pass each interval's `contents` to the grammar's `match` method, the resulting nodes and // their children will have intervals that are associated with a different input, i.e., a // substring of the original input. The following operation will fix this problem for us. s.addOperation('fixIntervals(idxOffset)', { _default: function(children) { var idxOffset = this.args.idxOffset; this.interval.inputStream = inputStream; this.interval.startIdx += idxOffset; this.interval.endIdx += idxOffset; if (!this.isTerminal()) { children.forEach(function(child) { child.fixIntervals(idxOffset); }); } } }); // Now we're finally ready to reconstruct the discarded CST nodes. var discardedNodes = intervals.map(function(interval) { var r = grammar.match(interval.contents, 'spaces'); s(r).fixIntervals(interval.startIdx); return r._cst; }); // Rather than return a bunch of CST nodes and make the caller of this method loop over them, // we can construct a single CST node that is the parent of all of the discarded nodes. An // `IterationNode` is the obvious choice for this. discardedNodes = new nodes.IterationNode( grammar, discardedNodes, discardedNodes.length === 0 ? new Interval(inputStream, 0, 0) : new Interval( inputStream, discardedNodes[0].interval.startIdx, discardedNodes[discardedNodes.length - 1].interval.endIdx)); // But remember that a CST node can't be used directly by clients. What we really need to return // from this method is a successful `MatchResult` that can be used with the clients' semantics. // We already have one -- `this` -- but it's got a different CST node inside. So we create a new // object that delegates to `this`, and override its `_cst` property. var r = Object.create(this); r._cst = discardedNodes; // We also override its `getDiscardedSpaces` method, in case someone decides to call it. r.getDiscardedSpaces = function() { return r; }; return r; }; // ----------------- MatchFailure ----------------- function MatchFailure(state) { this.state = state; common.defineLazyProperty(this, '_failures', function() { return this.state.getFailures(); }); common.defineLazyProperty(this, 'message', function() { var source = this.state.inputStream.source; if (typeof source !== 'string') { return 'match failed at position ' + this.getRightmostFailurePosition(); } var detail = 'Expected ' + this.getExpectedText(); return util.getLineAndColumnMessage(source, this.getRightmostFailurePosition()) + detail; }); common.defineLazyProperty(this, 'shortMessage', function() { if (typeof this.state.inputStream.source !== 'string') { return 'match failed at position ' + this.getRightmostFailurePosition(); } var detail = 'expected ' + this.getExpectedText(); return getShortMatchErrorMessage( this.getRightmostFailurePosition(), this.state.inputStream.source, detail); }); } inherits(MatchFailure, MatchResult); MatchFailure.prototype.toString = function() { return '[MatchFailure at position ' + this.getRightmostFailurePosition() + ']'; }; MatchFailure.prototype.failed = function() { return true; }; MatchFailure.prototype.getRightmostFailurePosition = function() { return this.state.getRightmostFailurePosition(); }; MatchFailure.prototype.getRightmostFailures = function() { return this._failures; }; // Return a string summarizing the expected contents of the input stream when // the match failure occurred. MatchFailure.prototype.getExpectedText = function() { var sb = new common.StringBuffer(); var failures = this.getRightmostFailures(); // Filter out the fluffy failures to make the default error messages more useful failures = failures.filter(function(failure) { return !failure.isFluffy(); }); for (var idx = 0; idx < failures.length; idx++) { if (idx > 0) { if (idx === failures.length - 1) { sb.append((failures.length > 2 ? ', or ' : ' or ')); } else { sb.append(', '); } } sb.append(failures[idx].toString()); } return sb.contents(); }; MatchFailure.prototype.getInterval = function() { var pos = this.state.getRightmostFailurePosition(); return new Interval(this.state.inputStream, pos, pos); }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = MatchResult; },{"./Interval":41,"./common":48,"./nodes":51,"./util":68,"inherits":33}],43:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var extend = require('util-extend'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function Namespace() { } Namespace.prototype = Object.create(null); Namespace.asNamespace = function(objOrNamespace) { if (objOrNamespace instanceof Namespace) { return objOrNamespace; } return Namespace.createNamespace(objOrNamespace); }; // Create a new namespace. If `optProps` is specified, all of its properties // will be copied to the new namespace. Namespace.createNamespace = function(optProps) { return Namespace.extend(Namespace.prototype, optProps); }; // Create a new namespace which extends another namespace. If `optProps` is // specified, all of its properties will be copied to the new namespace. Namespace.extend = function(namespace, optProps) { if (namespace !== Namespace.prototype && !(namespace instanceof Namespace)) { throw new TypeError('not a Namespace object: ' + namespace); } var ns = Object.create(namespace, { constructor: { value: Namespace, enumerable: false, writable: true, configurable: true } }); return extend(ns, optProps); }; // TODO: Should this be a regular method? Namespace.toString = function(ns) { return Object.prototype.toString.call(ns); }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Namespace; },{"util-extend":35}],44:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function PosInfo(state) { this.state = state; this.applicationMemoKeyStack = []; // a stack of "memo keys" of the active applications this.memo = {}; this.currentLeftRecursion = undefined; } PosInfo.prototype = { isActive: function(application) { return this.applicationMemoKeyStack.indexOf(application.toMemoKey()) >= 0; }, enter: function(application) { this.state.enter(application); this.applicationMemoKeyStack.push(application.toMemoKey()); }, exit: function() { this.state.exit(); this.applicationMemoKeyStack.pop(); }, startLeftRecursion: function(headApplication, memoRec) { memoRec.isLeftRecursion = true; memoRec.headApplication = headApplication; memoRec.nextLeftRecursion = this.currentLeftRecursion; this.currentLeftRecursion = memoRec; var applicationMemoKeyStack = this.applicationMemoKeyStack; var indexOfFirstInvolvedRule = applicationMemoKeyStack.indexOf(headApplication.toMemoKey()) + 1; var involvedApplicationMemoKeys = applicationMemoKeyStack.slice(indexOfFirstInvolvedRule); memoRec.isInvolved = function(applicationMemoKey) { return involvedApplicationMemoKeys.indexOf(applicationMemoKey) >= 0; }; memoRec.updateInvolvedApplicationMemoKeys = function() { for (var idx = indexOfFirstInvolvedRule; idx < applicationMemoKeyStack.length; idx++) { var applicationMemoKey = applicationMemoKeyStack[idx]; if (!this.isInvolved(applicationMemoKey)) { involvedApplicationMemoKeys.push(applicationMemoKey); } } }; }, endLeftRecursion: function() { this.currentLeftRecursion = this.currentLeftRecursion.nextLeftRecursion; }, // Note: this method doesn't get called for the "head" of a left recursion -- for LR heads, // the memoized result (which starts out being a failure) is always used. shouldUseMemoizedResult: function(memoRec) { if (!memoRec.isLeftRecursion) { return true; } var applicationMemoKeyStack = this.applicationMemoKeyStack; for (var idx = 0; idx < applicationMemoKeyStack.length; idx++) { var applicationMemoKey = applicationMemoKeyStack[idx]; if (memoRec.isInvolved(applicationMemoKey)) { return false; } } return true; } }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = PosInfo; },{}],45:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var Symbol = require('es6-symbol'); // eslint-disable-line no-undef var inherits = require('inherits'); var MatchResult = require('./MatchResult'); var IterationNode = require('./nodes').IterationNode; var common = require('./common'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- // ----------------- Wrappers ----------------- // Wrappers decorate CST nodes with all of the functionality (i.e., operations and attributes) // provided by a Semantics (see below). `Wrapper` is the abstract superclass of all wrappers. A // `Wrapper` must have `_node` and `_semantics` instance variables, which refer to the CST node and // Semantics (resp.) for which it was created, and a `_childWrappers` instance variable which is // used to cache the wrapper instances that are created for its child nodes. Setting these instance // variables is the responsibility of the constructor of each Semantics-specific subclass of // `Wrapper`. function Wrapper() {} Wrapper.prototype.toString = function() { return '[semantics wrapper for ' + this._node.grammar.name + ']'; }; // Returns the wrapper of the specified child node. Child wrappers are created lazily and cached in // the parent wrapper's `_childWrappers` instance variable. Wrapper.prototype.child = function(idx) { if (!(0 <= idx && idx < this._node.numChildren())) { // TODO: Consider throwing an exception here. return undefined; } var childWrapper = this._childWrappers[idx]; if (!childWrapper) { childWrapper = this._childWrappers[idx] = this._semantics.wrap(this._node.childAt(idx)); } return childWrapper; }; // Returns an array containing the wrappers of all of the children of the node associated with this // wrapper. Wrapper.prototype._children = function() { // Force the creation of all child wrappers for (var idx = 0; idx < this._node.numChildren(); idx++) { this.child(idx); } return this._childWrappers; }; // Returns `true` if the CST node associated with this wrapper corresponds to an iteration // expression, i.e., a Kleene-*, Kleene-+, or an optional. Returns `false` otherwise. Wrapper.prototype.isIteration = function() { return this._node.isIteration(); }; // Returns `true` if the CST node associated with this wrapper is a terminal node, `false` // otherwise. Wrapper.prototype.isTerminal = function() { return this._node.isTerminal(); }; // Returns `true` if the CST node associated with this wrapper is a nonterminal node, `false` // otherwise. Wrapper.prototype.isNonterminal = function() { return this._node.isNonterminal(); }; // Returns `true` if the CST node associated with this wrapper is a nonterminal node // corresponding to a syntactic rule, `false` otherwise. Wrapper.prototype.isSyntactic = function() { return this.isNonterminal() && this._node.isSyntactic(); }; // Returns `true` if the CST node associated with this wrapper is a nonterminal node // corresponding to a lexical rule, `false` otherwise. Wrapper.prototype.isLexical = function() { return this.isNonterminal() && this._node.isLexical(); }; // Returns `true` if the CST node associated with this wrapper is an iterator node // having either one or no child (? operator), `false` otherwise. // Otherwise, throws an exception. Wrapper.prototype.isOptional = function() { return this._node.isOptional(); }; // Create a new IterationNode in the same semantics as this wrapper. Wrapper.prototype.iteration = function(optElements) { var iter = new IterationNode(this._node.grammar, optElements || [], this.interval, false); return this._semantics.wrap(iter); }; Object.defineProperties(Wrapper.prototype, { // Returns an array containing the children of this CST node. children: {get: function() { return this._children(); }}, // Returns the name of grammar rule that created this CST node. ctorName: {get: function() { return this._node.ctorName; }}, // Returns the interval consumed by the CST node associated with this wrapper. interval: {get: function() { return this._node.interval; }}, // Returns the number of children of this CST node. numChildren: {get: function() { return this._node.numChildren(); }}, // Returns the primitive value of this CST node, if it's a terminal node. Otherwise, // throws an exception. primitiveValue: { get: function() { if (this.isTerminal()) { return this._node.primitiveValue; } throw new TypeError( "tried to access the 'primitiveValue' attribute of a non-terminal CST node"); } } }); // ----------------- Semantics ----------------- // A Semantics is a container for a family of Operations and Attributes for a given grammar. // Semantics enable modularity (different clients of a grammar can create their set of operations // and attributes in isolation) and extensibility even when operations and attributes are mutually- // recursive. This constructor should not be called directly except from // `Semantics.createSemantics`. The normal ways to create a Semantics, given a grammar 'g', are // `g.semantics()` and `g.extendSemantics(parentSemantics)`. function Semantics(grammar, superSemantics) { var self = this; this.grammar = grammar; this.checkedActionDicts = false; // Constructor for wrapper instances, which are passed as the arguments to the semantic actions // of an operation or attribute. Operations and attributes require double dispatch: the semantic // action is chosen based on both the node's type and the semantics. Wrappers ensure that // the `execute` method is called with the correct (most specific) semantics object as an // argument. this.Wrapper = function(node) { self.checkActionDictsIfHaventAlready(); this._semantics = self; this._node = node; this._childWrappers = []; }; this.super = superSemantics; if (superSemantics) { if (grammar !== this.super.grammar && !grammar._inheritsFrom(this.super.grammar)) { throw new Error( "Cannot extend a semantics for grammar '" + this.super.grammar.name + "' for use with grammar '" + grammar.name + "' (not a sub-grammar)"); } inherits(this.Wrapper, this.super.Wrapper); this.operations = Object.create(this.super.operations); this.attributes = Object.create(this.super.attributes); this.attributeKeys = Object.create(null); // Assign unique symbols for each of the attributes inherited from the super-semantics so that // they are memoized independently. for (var attributeName in this.attributes) { this.attributeKeys[attributeName] = Symbol(); } } else { inherits(this.Wrapper, Wrapper); this.operations = Object.create(null); this.attributes = Object.create(null); this.attributeKeys = Object.create(null); } } Semantics.prototype.toString = function() { return '[semantics for ' + this.grammar.name + ']'; }; Semantics.prototype.checkActionDictsIfHaventAlready = function() { if (!this.checkedActionDicts) { this.checkActionDicts(); this.checkedActionDicts = true; } }; // Checks that the action dictionaries for all operations and attributes in this semantics, // including the ones that were inherited from the super-semantics, agree with the grammar. // Throws an exception if one or more of them doesn't. Semantics.prototype.checkActionDicts = function() { for (var name in this.operations) { this.operations[name].checkActionDict(this.grammar); } for (name in this.attributes) { this.attributes[name].checkActionDict(this.grammar); } }; var prototypeGrammar; var prototypeGrammarSemantics; // This method is called from main.js once Ohm has loaded. Semantics.initPrototypeParser = function(grammar) { prototypeGrammarSemantics = grammar.semantics().addOperation('parse', { NameNoFormals: function(n) { return { name: n.parse(), formals: [] }; }, NameAndFormals: function(n, fs) { return { name: n.parse(), formals: fs.parse()[0] || [] }; }, Formals: function(oparen, fs, cparen) { return fs.asIteration().parse(); }, name: function(first, rest) { return this.interval.contents; } }); prototypeGrammar = grammar; }; function parsePrototype(nameAndFormalArgs, allowFormals) { if (!prototypeGrammar) { // The Operations and Attributes grammar won't be available while Ohm is loading, // but we can get away the following simplification b/c none of the operations // that are used while loading take arguments. common.assert(nameAndFormalArgs.indexOf('(') === -1); return { name: nameAndFormalArgs, formals: [] }; } var r = prototypeGrammar.match( nameAndFormalArgs, allowFormals ? 'NameAndFormals' : 'NameNoFormals'); if (r.failed()) { throw new Error(r.message); } return prototypeGrammarSemantics(r).parse(); } Semantics.prototype.addOperationOrAttribute = function(type, nameAndFormalArgs, actionDict) { var typePlural = type + 's'; var parsedNameAndFormalArgs = parsePrototype(nameAndFormalArgs, type === 'operation'); var name = parsedNameAndFormalArgs.name; var formals = parsedNameAndFormalArgs.formals; // TODO: check that there are no duplicate formal arguments this.assertNewName(name, type); // Create the action dictionary for this operation / attribute that contains a `_default` action // which defines the default behavior of iteration, terminal, and non-terminal nodes... var realActionDict = { _default: function(children) { var self = this; var thisThing = this._semantics[typePlural][name]; var args = thisThing.formals.map(function(formal) { return self.args[formal]; }); if (this.isIteration()) { // This CST node corresponds to an iteration expression in the grammar (*, +, or ?). The // default behavior is to map this operation or attribute over all of its child nodes. return children.map(function(child) { return doIt.apply(child, args); }); } if (this.isTerminal()) { // This CST node corresponds to a terminal expression in the grammar (e.g., "+"). The // default behavior is to return that terminal's primitive value. return this.primitiveValue; } // This CST node corresponds to a non-terminal in the grammar (e.g., AddExpr). The fact that // we got here means that this action dictionary doesn't have an action for this particular // non-terminal or a generic `_nonterminal` action. if (children.length === 1) { // As a convenience, if this node only has one child, we just return the result of // applying this operation / attribute to the child node. return doIt.apply(children[0], args); } else { // Otherwise, we throw an exception to let the programmer know that we don't know what // to do with this node. throw new Error( 'Missing semantic action for ' + this.ctorName + ' in ' + name + ' ' + type); } } }; // ... and add in the actions supplied by the programmer, which may override some or all of the // default ones. Object.keys(actionDict).forEach(function(name) { realActionDict[name] = actionDict[name]; }); var entry = type === 'operation' ? new Operation(name, formals, realActionDict) : new Attribute(name, realActionDict); // The following check is not strictly necessary (it will happen later anyway) but it's better to // catch errors early. entry.checkActionDict(this.grammar); this[typePlural][name] = entry; function doIt() { // Dispatch to most specific version of this operation / attribute -- it may have been // overridden by a sub-semantics. var thisThing = this._semantics[typePlural][name]; // Check that the caller passed the correct number of arguments. if (arguments.length !== thisThing.formals.length) { throw new Error( 'Invalid number of arguments passed to ' + name + ' ' + type + ' (expected ' + thisThing.formals.length + ', got ' + arguments.length + ')'); } // Create an "arguments object" from the arguments that were passed to this // operation / attribute. var args = Object.create(null); for (var idx = 0; idx < arguments.length; idx++) { var formal = thisThing.formals[idx]; args[formal] = arguments[idx]; } var oldArgs = this.args; this.args = args; var ans = thisThing.execute(this._semantics, this); this.args = oldArgs; return ans; } if (type === 'operation') { this.Wrapper.prototype[name] = doIt; this.Wrapper.prototype[name].toString = function() { return '[' + name + ' operation]'; }; } else { Object.defineProperty(this.Wrapper.prototype, name, {get: doIt}); this.attributeKeys[name] = Symbol(); } }; Semantics.prototype.extendOperationOrAttribute = function(type, name, actionDict) { var typePlural = type + 's'; // Make sure that `name` really is just a name, i.e., that it doesn't also contain formals. parsePrototype(name, false); if (!(this.super && name in this.super[typePlural])) { throw new Error('Cannot extend ' + type + " '" + name + "': did not inherit an " + type + ' with that name'); } if (Object.prototype.hasOwnProperty.call(this[typePlural], name)) { throw new Error('Cannot extend ' + type + " '" + name + "' again"); } // Create a new operation / attribute whose actionDict delegates to the super operation / // attribute's actionDict, and which has all the keys from `inheritedActionDict`. var inheritedFormals = this[typePlural][name].formals; var inheritedActionDict = this[typePlural][name].actionDict; var newActionDict = Object.create(inheritedActionDict); Object.keys(actionDict).forEach(function(name) { newActionDict[name] = actionDict[name]; }); this[typePlural][name] = type === 'operation' ? new Operation(name, inheritedFormals, newActionDict) : new Attribute(name, newActionDict); // The following check is not strictly necessary (it will happen later anyway) but it's better to // catch errors early. this[typePlural][name].checkActionDict(this.grammar); }; Semantics.prototype.assertNewName = function(name, type) { if (Wrapper.prototype.hasOwnProperty(name)) { throw new Error( 'Cannot add ' + type + " '" + name + "': that's a reserved name"); } if (name in this.operations) { throw new Error( 'Cannot add ' + type + " '" + name + "': an operation with that name already exists"); } if (name in this.attributes) { throw new Error( 'Cannot add ' + type + " '" + name + "': an attribute with that name already exists"); } }; // Returns a wrapper for the given CST `node` in this semantics. // If `node` is already a wrapper, returns `node` itself. // TODO: why is this needed? Semantics.prototype.wrap = function(node) { return node instanceof this.Wrapper ? node : new this.Wrapper(node); }; // Creates a new Semantics instance for `grammar`, inheriting operations and attributes from // `optSuperSemantics`, if it is specified. Returns a function that acts as a proxy for the new // Semantics instance. When that function is invoked with a CST node as an argument, it returns // a wrapper for that node which gives access to the operations and attributes provided by this // semantics. Semantics.createSemantics = function(grammar, optSuperSemantics) { var s = new Semantics( grammar, optSuperSemantics !== undefined ? optSuperSemantics : Semantics.BuiltInSemantics._getSemantics()); // To enable clients to invoke a semantics like a function, return a function that acts as a proxy // for `s`, which is the real `Semantics` instance. var proxy = function ASemantics(matchResult) { if (!(matchResult instanceof MatchResult)) { throw new TypeError( 'Semantics expected a MatchResult, but got ' + common.unexpectedObjToString(matchResult)); } if (!matchResult.succeeded()) { throw new TypeError( 'cannot apply Semantics to ' + matchResult.toString()); } var cst = matchResult._cst; if (cst.grammar !== grammar) { throw new Error( "Cannot use a CST node created by grammar '" + cst.grammar.name + "' with a semantics for '" + grammar.name + "'"); } return s.wrap(cst); }; // Forward public methods from the proxy to the semantics instance. proxy.addOperation = function(nameAndFormalArgs, actionDict) { s.addOperationOrAttribute.call(s, 'operation', nameAndFormalArgs, actionDict); return proxy; }; proxy.extendOperation = function(name, actionDict) { s.extendOperationOrAttribute.call(s, 'operation', name, actionDict); return proxy; }; proxy.addAttribute = function(name, actionDict) { s.addOperationOrAttribute.call(s, 'attribute', name, actionDict); return proxy; }; proxy.extendAttribute = function(name, actionDict) { s.extendOperationOrAttribute.call(s, 'attribute', name, actionDict); return proxy; }; // Make the proxy's toString() work. proxy.toString = s.toString.bind(s); // Returns the semantics for the proxy. proxy._getSemantics = function() { return s; }; return proxy; }; Semantics.initBuiltInSemantics = function(builtInRules) { var actions = { empty: function() { return this.iteration(); }, nonEmpty: function(first, _, rest) { return this.iteration([first].concat(rest.children)); } }; Semantics.BuiltInSemantics = Semantics .createSemantics(builtInRules, null) .addOperation('asIteration', { emptyListOf: actions.empty, nonemptyListOf: actions.nonEmpty, EmptyListOf: actions.empty, NonemptyListOf: actions.nonEmpty }); }; // ----------------- Operation ----------------- // An Operation represents a function to be applied to a concrete syntax tree (CST) -- it's very // similar to a Visitor (http://en.wikipedia.org/wiki/Visitor_pattern). An operation is executed by // recursively walking the CST, and at each node, invoking the matching semantic action from // `actionDict`. See `Operation.prototype.execute` for details of how a CST node's matching semantic // action is found. function Operation(name, formals, actionDict) { this.name = name; this.formals = formals; this.actionDict = actionDict; } Operation.prototype.typeName = 'operation'; Operation.prototype.checkActionDict = function(grammar) { grammar._checkTopDownActionDict(this.typeName, this.name, this.actionDict); }; // Execute this operation on the CST node associated with `nodeWrapper` in the context of the given // Semantics instance. Operation.prototype.execute = function(semantics, nodeWrapper) { // Look for a semantic action whose name matches the node's constructor name, which is either the // name of a rule in the grammar, or '_terminal' (for a terminal node), or '_iter' (for an // iteration node). In the latter case, the action function receives a single argument, which is // an array containing all of the children of the CST node. var actionFn = this.actionDict[nodeWrapper._node.ctorName]; if (actionFn) { return this.doAction(semantics, nodeWrapper, actionFn, nodeWrapper.isIteration()); } // The action dictionary does not contain a semantic action for this specific type of node. // If this is a nonterminal node and the programmer has provided a `_nonterminal` semantic // action, we invoke it: if (nodeWrapper.isNonterminal()) { actionFn = this.actionDict._nonterminal; if (actionFn) { return this.doAction(semantics, nodeWrapper, actionFn, true); } } // Otherwise, we invoke the '_default' semantic action. return this.doAction(semantics, nodeWrapper, this.actionDict._default, true); }; // Invoke `actionFn` on the CST node that corresponds to `nodeWrapper`, in the context of // `semantics`. If `optPassChildrenAsArray` is truthy, `actionFn` will be called with a single // argument, which is an array of wrappers. Otherwise, the number of arguments to `actionFn` will // be equal to the number of children in the CST node. Operation.prototype.doAction = function(semantics, nodeWrapper, actionFn, optPassChildrenAsArray) { return optPassChildrenAsArray ? actionFn.call(nodeWrapper, nodeWrapper._children()) : actionFn.apply(nodeWrapper, nodeWrapper._children()); }; // ----------------- Attribute ----------------- // Attributes are Operations whose results are memoized. This means that, for any given semantics, // the semantic action for a CST node will be invoked no more than once. function Attribute(name, actionDict) { this.name = name; this.formals = []; this.actionDict = actionDict; } inherits(Attribute, Operation); Attribute.prototype.typeName = 'attribute'; Attribute.prototype.execute = function(semantics, nodeWrapper) { var node = nodeWrapper._node; var key = semantics.attributeKeys[this.name]; if (!node.hasOwnProperty(key)) { // The following is a super-send -- isn't JS beautiful? :/ node[key] = Operation.prototype.execute.call(this, semantics, nodeWrapper); } return node[key]; }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Semantics; },{"./MatchResult":42,"./common":48,"./nodes":51,"es6-symbol":15,"inherits":33}],46:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var PosInfo = require('./PosInfo'); var Trace = require('./Trace'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- var RM_RIGHTMOST_FAILURE_POSITION = 0; var RM_RIGHTMOST_FAILURES = 1; var applySpaces = new pexprs.Apply('spaces'); function State(grammar, inputStream, startRule, opts) { this.grammar = grammar; this.origInputStream = inputStream; this.startRule = startRule; this.tracingEnabled = opts.trace || false; this.matchNodes = opts.matchNodes || false; this.init(RM_RIGHTMOST_FAILURE_POSITION); } State.prototype = { init: function(recordingMode) { this.bindings = []; this.inputStreamStack = []; this.posInfosStack = []; this.pushInputStream(this.origInputStream); this.applicationStack = []; this.inLexifiedContextStack = [false]; this.recordingMode = recordingMode; if (recordingMode === RM_RIGHTMOST_FAILURE_POSITION) { this.rightmostFailurePosition = -1; } else if (recordingMode === RM_RIGHTMOST_FAILURES) { // We always run in *rightmost failure position* recording mode before running in // *rightmost failures* recording mode. And since the traces generated by each of // these passes would be identical, there's no need to record it now if we have // already recorded it in the first pass. this.tracingEnabled = false; } else { throw new Error('invalid recording mode: ' + recordingMode); } if (this.isTracing()) { this.trace = []; } }, enter: function(app) { this.applicationStack.push(app); this.inLexifiedContextStack.push(false); }, exit: function() { this.applicationStack.pop(); this.inLexifiedContextStack.pop(); }, enterLexifiedContext: function() { this.inLexifiedContextStack.push(true); }, exitLexifiedContext: function() { this.inLexifiedContextStack.pop(); }, currentApplication: function() { return this.applicationStack[this.applicationStack.length - 1]; }, inSyntacticRule: function() { if (typeof this.inputStream.source !== 'string') { return false; } var currentApplication = this.currentApplication(); return currentApplication && currentApplication.isSyntactic(); }, inSyntacticContext: function() { return this.inSyntacticRule() && !this.inLexifiedContext(); }, inLexifiedContext: function() { return this.inLexifiedContextStack[this.inLexifiedContextStack.length - 1]; }, skipSpaces: function() { var origFailuresInfo = this.getFailuresInfo(); this.eval(applySpaces); this.bindings.pop(); this.restoreFailuresInfo(origFailuresInfo); return this.inputStream.pos; }, skipSpacesIfInSyntacticContext: function() { return this.inSyntacticContext() ? this.skipSpaces() : this.inputStream.pos; }, truncateBindings: function(newLength) { // TODO: is this really faster than setting the `length` property? while (this.bindings.length > newLength) { this.bindings.pop(); } }, pushInputStream: function(inputStream) { this.inputStreamStack.push(this.inputStream); this.posInfosStack.push(this.posInfos); this.inputStream = inputStream; this.posInfos = []; }, popInputStream: function() { this.inputStream = this.inputStreamStack.pop(); this.posInfos = this.posInfosStack.pop(); }, getCurrentPosInfo: function() { return this.getPosInfo(this.inputStream.pos); }, getPosInfo: function(pos) { var posInfo = this.posInfos[pos]; return posInfo || (this.posInfos[pos] = new PosInfo(this)); }, processFailure: function(pos, expr) { if (this.recordingMode === RM_RIGHTMOST_FAILURE_POSITION) { if (pos > this.rightmostFailurePosition) { this.rightmostFailurePosition = pos; } } else /* if (this.recordingMode === RM_RIGHTMOST_FAILURES) */ if (pos === this.rightmostFailurePosition) { // We're only interested in failures at the rightmost failure position that haven't // already been recorded. this.addRightmostFailure(expr.toFailure(this.grammar), false); } }, ensureRightmostFailures: function() { if (!this.rightmostFailures) { this.rightmostFailures = Object.create(null); } }, addRightmostFailure: function(failure, shouldCloneIfNew) { this.ensureRightmostFailures(); var key = failure.toKey(); if (!this.rightmostFailures[key]) { this.rightmostFailures[key] = shouldCloneIfNew ? failure.clone() : failure; } else if (this.rightmostFailures[key].isFluffy() && !failure.isFluffy()) { this.rightmostFailures[key].clearFluffy(); } }, addRightmostFailures: function(failures, shouldCloneIfNew) { var self = this; Object.keys(failures).forEach(function(key) { self.addRightmostFailure(failures[key], shouldCloneIfNew); }); }, cloneRightmostFailures: function() { if (!this.rightmostFailures) { return undefined; } var ans = Object.create(null); var self = this; Object.keys(this.rightmostFailures).forEach(function(key) { ans[key] = self.rightmostFailures[key].clone(); }); return ans; }, getRightmostFailurePosition: function() { return this.rightmostFailurePosition; }, getFailures: function() { if (this.recordingMode === RM_RIGHTMOST_FAILURE_POSITION) { // Rewind, then try to match the input again, recording failures. this.init(RM_RIGHTMOST_FAILURES); this.eval(new pexprs.Apply(this.startRule)); } this.ensureRightmostFailures(); var self = this; return Object.keys(this.rightmostFailures).map(function(key) { return self.rightmostFailures[key]; }); }, // Returns the memoized trace entry for `expr` at `pos`, if one exists, `null` otherwise. getMemoizedTraceEntry: function(pos, expr) { var posInfo = this.posInfos[pos]; if (posInfo && expr.ruleName) { var memoRec = posInfo.memo[expr.toMemoKey()]; if (memoRec) { return memoRec.traceEntry; } } return null; }, // Returns a new trace entry, with the currently active trace array as its children. getTraceEntry: function(pos, expr, cstNode) { var memoEntry = this.getMemoizedTraceEntry(pos, expr); return memoEntry ? memoEntry.cloneWithExpr(expr) : new Trace(this.inputStream, pos, expr, cstNode, this.trace); }, isTracing: function() { return this.tracingEnabled; }, useMemoizedResult: function(memoRec) { if (this.isTracing()) { this.trace.push(memoRec.traceEntry); } if (this.recordingMode === RM_RIGHTMOST_FAILURES && memoRec.failuresAtRightmostPosition) { this.addRightmostFailures(memoRec.failuresAtRightmostPosition, true); } if (memoRec.value) { this.inputStream.pos = memoRec.pos; this.bindings.push(memoRec.value); return true; } return false; }, // Evaluate `expr` and return `true` if it succeeded, `false` otherwise. On success, `bindings` // will have `expr.getArity()` more elements than before, and the input stream's position may // have increased. On failure, `bindings` and position will be unchanged. eval: function(expr) { var inputStream = this.inputStream; var origPos = inputStream.pos; var origNumBindings = this.bindings.length; if (this.recordingMode === RM_RIGHTMOST_FAILURES) { var origFailures = this.rightmostFailures; this.rightmostFailures = undefined; } if (this.isTracing()) { var origTrace = this.trace; this.trace = []; } // Do the actual evaluation. var ans = expr.eval(this); if (this.isTracing()) { var cstNode = ans ? this.bindings[this.bindings.length - 1] : null; var traceEntry = this.getTraceEntry(origPos, expr, cstNode); origTrace.push(traceEntry); this.trace = origTrace; } if (ans) { if (this.rightmostFailures && (inputStream.pos === this.rightmostFailurePosition || this.skipSpacesIfInSyntacticContext() === this.rightmostFailurePosition)) { var self = this; Object.keys(this.rightmostFailures).forEach(function(key) { self.rightmostFailures[key].makeFluffy(); }); } } else { // Reset the position and the bindings. inputStream.pos = origPos; this.truncateBindings(origNumBindings); } if (this.recordingMode === RM_RIGHTMOST_FAILURES && origFailures) { this.addRightmostFailures(origFailures, false); } return ans; }, getFailuresInfo: function() { if (this.recordingMode === RM_RIGHTMOST_FAILURE_POSITION) { return this.rightmostFailurePosition; } else /* if (this.recordingMode === RM_RIGHTMOST_FAILURES) */ { return this.rightmostFailures; } }, restoreFailuresInfo: function(failuresInfo) { if (this.recordingMode === RM_RIGHTMOST_FAILURE_POSITION) { this.rightmostFailurePosition = failuresInfo; } else /* if (this.recordingMode === RM_RIGHTMOST_FAILURES) */ { this.rightmostFailures = failuresInfo; } }, applySpaces: applySpaces }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = State; },{"./PosInfo":44,"./Trace":47,"./pexprs":67}],47:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var Interval = require('./Interval'); var common = require('./common'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- // Unicode characters that are used in the `toString` output. var BALLOT_X = '\u2717'; var CHECK_MARK = '\u2713'; var DOT_OPERATOR = '\u22C5'; var RIGHTWARDS_DOUBLE_ARROW = '\u21D2'; var SYMBOL_FOR_HORIZONTAL_TABULATION = '\u2409'; var SYMBOL_FOR_LINE_FEED = '\u240A'; var SYMBOL_FOR_CARRIAGE_RETURN = '\u240D'; function linkLeftRecursiveChildren(children) { for (var i = 0; i < children.length; ++i) { var child = children[i]; var nextChild = children[i + 1]; if (nextChild && child.expr === nextChild.expr) { child.replacedBy = nextChild; } } } function spaces(n) { return common.repeat(' ', n).join(''); } // Return a string representation of a portion of `inputStream` at offset `pos`. // The result will contain exactly `len` characters. function getInputExcerpt(inputStream, pos, len) { var excerpt = asEscapedString(inputStream.sourceSlice(pos, pos + len)); // Pad the output if necessary. if (excerpt.length < len) { return excerpt + common.repeat(' ', len - excerpt.length).join(''); } return excerpt; } function asEscapedString(obj) { if (typeof obj === 'string') { // Replace non-printable characters with visible symbols. return obj .replace(/ /g, DOT_OPERATOR) .replace(/\t/g, SYMBOL_FOR_HORIZONTAL_TABULATION) .replace(/\n/g, SYMBOL_FOR_LINE_FEED) .replace(/\r/g, SYMBOL_FOR_CARRIAGE_RETURN); } return String(obj); } // ----------------- Trace ----------------- function Trace(inputStream, pos, expr, cstNode, optChildren) { this.children = optChildren || []; this.expr = expr; if (cstNode) { this.interval = new Interval(inputStream, pos, inputStream.pos); this.cstNode = cstNode; } this.isLeftRecursive = false; this.pos = pos; this.inputStream = inputStream; this.succeeded = !!cstNode; } // A value that can be returned from visitor functions to indicate that a // node should not be recursed into. Trace.prototype.SKIP = {}; Object.defineProperty(Trace.prototype, 'displayString', { get: function() { return this.expr.toDisplayString(); } }); Trace.prototype.cloneWithExpr = function(expr) { var ans = new Trace(this.inputStream, this.pos, expr, this.cstNode, this.children); ans.isLeftRecursive = this.isLeftRecursive; ans.isMemoized = true; return ans; }; // Set the value of `isLeftRecursive` for this node. // If true, each child of this node represents one iteration of the "growing the seed" loop. Trace.prototype.setLeftRecursive = function(leftRecursive) { this.isLeftRecursive = leftRecursive; if (leftRecursive) { linkLeftRecursiveChildren(this.children); } }; // Recursively traverse this trace node and all its descendents, calling a visitor function // for each node that is visited. If `vistorObjOrFn` is an object, then its 'enter' property // is a function to call before visiting the children of a node, and its 'exit' property is // a function to call afterwards. If `visitorObjOrFn` is a function, it represents the 'enter' // function. // // The functions are called with three arguments: the Trace node, its parent Trace, and a number // representing the depth of the node in the tree. (The root node has depth 0.) `optThisArg`, if // specified, is the value to use for `this` when executing the visitor functions. Trace.prototype.walk = function(visitorObjOrFn, optThisArg) { var visitor = visitorObjOrFn; if (typeof visitor === 'function') { visitor = {enter: visitor}; } return (function _walk(node, parent, depth) { var recurse = true; if (visitor.enter) { if (visitor.enter.call(optThisArg, node, parent, depth) === Trace.prototype.SKIP) { recurse = false; } } if (recurse) { node.children.forEach(function(c) { if (c && ('walk' in c)) { _walk(c, node, depth + 1); } }); if (visitor.exit) { visitor.exit.call(optThisArg, node, parent, depth); } } })(this, null, 0); }; // Return a string representation of the trace. // Sample: // 12⋅+⋅2⋅*⋅3 ✓ exp ⇒ "12" // 12⋅+⋅2⋅*⋅3 ✓ addExp (LR) ⇒ "12" // 12⋅+⋅2⋅*⋅3 ✗ addExp_plus Trace.prototype.toString = function() { var sb = new common.StringBuffer(); this.walk(function(node, parent, depth) { var ctorName = node.expr.constructor.name; if (ctorName === 'Alt') { return; // Don't print anything for Alt nodes. } sb.append(getInputExcerpt(node.inputStream, node.pos, 10) + spaces(depth * 2 + 1)); sb.append((node.succeeded ? CHECK_MARK : BALLOT_X) + ' ' + node.displayString); if (node.isLeftRecursive) { sb.append(' (LR)'); } if (node.succeeded) { var contents = asEscapedString(node.interval.contents); sb.append(' ' + RIGHTWARDS_DOUBLE_ARROW + ' '); sb.append(typeof contents === 'string' ? '"' + contents + '"' : contents); } sb.append('\n'); }); return sb.contents(); }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = Trace; },{"./Interval":41,"./common":48}],48:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var extend = require('util-extend'); // -------------------------------------------------------------------- // Private Stuff // -------------------------------------------------------------------- // Helpers var escapeStringFor = {}; for (var c = 0; c < 128; c++) { escapeStringFor[c] = String.fromCharCode(c); } escapeStringFor["'".charCodeAt(0)] = "\\'"; escapeStringFor['"'.charCodeAt(0)] = '\\"'; escapeStringFor['\\'.charCodeAt(0)] = '\\\\'; escapeStringFor['\b'.charCodeAt(0)] = '\\b'; escapeStringFor['\f'.charCodeAt(0)] = '\\f'; escapeStringFor['\n'.charCodeAt(0)] = '\\n'; escapeStringFor['\r'.charCodeAt(0)] = '\\r'; escapeStringFor['\t'.charCodeAt(0)] = '\\t'; escapeStringFor['\u000b'.charCodeAt(0)] = '\\v'; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- exports.abstract = function() { throw new Error( 'this method is abstract! ' + '(it has no implementation in class ' + this.constructor.name + ')'); }; exports.assert = function(cond, message) { if (!cond) { throw new Error(message); } }; // Define a lazily-computed, non-enumerable property named `propName` // on the object `obj`. `getterFn` will be called to compute the value the // first time the property is accessed. exports.defineLazyProperty = function(obj, propName, getterFn) { var memo; Object.defineProperty(obj, propName, { get: function() { if (!memo) { memo = getterFn.call(this); } return memo; } }); }; exports.clone = function(obj) { if (obj) { return extend({}, obj); } return obj; }; exports.extend = extend; exports.repeatFn = function(fn, n) { var arr = []; while (n-- > 0) { arr.push(fn()); } return arr; }; exports.repeatStr = function(str, n) { return new Array(n + 1).join(str); }; exports.repeat = function(x, n) { return exports.repeatFn(function() { return x; }, n); }; exports.getDuplicates = function(array) { var duplicates = []; for (var idx = 0; idx < array.length; idx++) { var x = array[idx]; if (array.lastIndexOf(x) !== idx && duplicates.indexOf(x) < 0) { duplicates.push(x); } } return duplicates; }; exports.fail = {}; exports.isSyntactic = function(ruleName) { var firstChar = ruleName[0]; return firstChar === firstChar.toUpperCase(); }; exports.isLexical = function(ruleName) { return !exports.isSyntactic(ruleName); }; exports.padLeft = function(str, len, optChar) { var ch = optChar || ' '; if (str.length < len) { return exports.repeatStr(ch, len - str.length) + str; } return str; }; // StringBuffer exports.StringBuffer = function() { this.strings = []; }; exports.StringBuffer.prototype.append = function(str) { this.strings.push(str); }; exports.StringBuffer.prototype.contents = function() { return this.strings.join(''); }; // Character escaping and unescaping exports.escapeChar = function(c, optDelim) { var charCode = c.charCodeAt(0); if ((c === '"' || c === "'") && optDelim && c !== optDelim) { return c; } else if (charCode < 128) { return escapeStringFor[charCode]; } else if (128 <= charCode && charCode < 256) { return '\\x' + exports.padLeft(charCode.toString(16), 2, '0'); } else { return '\\u' + exports.padLeft(charCode.toString(16), 4, '0'); } }; exports.unescapeChar = function(s) { if (s.charAt(0) === '\\') { switch (s.charAt(1)) { case 'b': return '\b'; case 'f': return '\f'; case 'n': return '\n'; case 'r': return '\r'; case 't': return '\t'; case 'v': return '\v'; case 'x': return String.fromCharCode(parseInt(s.substring(2, 4), 16)); case 'u': return String.fromCharCode(parseInt(s.substring(2, 6), 16)); default: return s.charAt(1); } } else { return s; } }; // Helper for producing a description of an unknown object in a safe way. // Especially useful for error messages where an unexpected type of object was encountered. exports.unexpectedObjToString = function(obj) { if (obj == null) { return String(obj); } var baseToString = Object.prototype.toString.call(obj); try { var typeName; if (obj.constructor && obj.constructor.name) { typeName = obj.constructor.name; } else if (baseToString.indexOf('[object ') === 0) { typeName = baseToString.slice(8, -1); // Extract e.g. "Array" from "[object Array]". } else { typeName = typeof obj; } return typeName + ': ' + JSON.stringify(String(obj)); } catch (e) { return baseToString; } }; },{"util-extend":35}],49:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var Namespace = require('./Namespace'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function createError(message, optInterval) { var e; if (optInterval) { e = new Error(optInterval.getLineAndColumnMessage() + message); e.shortMessage = message; e.interval = optInterval; } else { e = new Error(message); } return e; } // ----------------- errors about intervals ----------------- function intervalSourcesDontMatch() { return createError("Interval sources don't match"); } // ----------------- errors about grammars ----------------- // Grammar syntax error function grammarSyntaxError(matchFailure) { var e = new Error(); Object.defineProperty(e, 'message', {get: function() { return matchFailure.message; }}); Object.defineProperty(e, 'shortMessage', {get: function() { return 'Expected ' + matchFailure.getExpectedText(); }}); e.interval = matchFailure.getInterval(); return e; } // Undeclared grammar function undeclaredGrammar(grammarName, namespace, interval) { var message = namespace ? 'Grammar ' + grammarName + ' is not declared in namespace ' + Namespace.toString(namespace) : 'Undeclared grammar ' + grammarName; return createError(message, interval); } // Duplicate grammar declaration function duplicateGrammarDeclaration(grammar, namespace) { return createError('Grammar ' + grammar.name + ' is already declared in this namespace'); } // ----------------- rules ----------------- // Undeclared rule function undeclaredRule(ruleName, grammarName, optInterval) { return createError( 'Rule ' + ruleName + ' is not declared in grammar ' + grammarName, optInterval); } // Cannot override undeclared rule function cannotOverrideUndeclaredRule(ruleName, grammarName, body) { return createError( 'Cannot override rule ' + ruleName + ' because it is not declared in ' + grammarName, body.definitionInterval); } // Cannot extend undeclared rule function cannotExtendUndeclaredRule(ruleName, grammarName, body) { return createError( 'Cannot extend rule ' + ruleName + ' because it is not declared in ' + grammarName, body.definitionInterval); } // Duplicate rule declaration function duplicateRuleDeclaration(ruleName, offendingGrammarName, declGrammarName, body) { var message = "Duplicate declaration for rule '" + ruleName + "' in grammar '" + offendingGrammarName + "'"; if (offendingGrammarName !== declGrammarName) { message += " (originally declared in '" + declGrammarName + "')"; } return createError(message, body.definitionInterval); } // Wrong number of parameters function wrongNumberOfParameters(ruleName, expected, actual, body) { return createError( 'Wrong number of parameters for rule ' + ruleName + ' (expected ' + expected + ', got ' + actual + ')', body && body.definitionInterval); } // Wrong number of arguments function wrongNumberOfArguments(ruleName, expected, actual, expr) { return createError( 'Wrong number of arguments for rule ' + ruleName + ' (expected ' + expected + ', got ' + actual + ')', expr.interval); } // Duplicate parameter names function duplicateParameterNames(ruleName, duplicates, body) { return createError( 'Duplicate parameter names in rule ' + ruleName + ': ' + duplicates.join(','), body.definitionInterval); } // Invalid parameter expression function invalidParameter(ruleName, expr) { return createError( 'Invalid parameter to rule ' + ruleName + ': ' + expr + ' has arity ' + expr.getArity() + ', but parameter expressions ' + 'must have arity 1', expr.interval); } // Application of syntactic rule from lexical rule function applicationOfSyntacticRuleFromLexicalContext(ruleName, applyExpr) { return createError( 'Cannot apply syntactic rule ' + ruleName + ' from here (inside a lexical context)', applyExpr.interval); } function exprMixesValueAndStringExpressions(expr, optRuleName) { // TODO: Improve the reporting here. var desc = (optRuleName ? 'Rule ' + optRuleName : 'Expression') + ' mixes value and string expressions'; return createError(desc, expr.interval); } // ----------------- Kleene operators ----------------- function kleeneExprHasNullableOperand(kleeneExpr) { return createError( 'Nullable expression ' + kleeneExpr.expr.interval.contents + " is not allowed inside '" + kleeneExpr.operator + "' (possible infinite loop)", kleeneExpr.expr.interval); } // ----------------- arity ----------------- function inconsistentArity(ruleName, expected, actual, expr) { return createError( 'Rule ' + ruleName + ' involves an alternation which has inconsistent arity ' + '(expected ' + expected + ', got ' + actual + ')', expr.interval); } // ----------------- properties ----------------- function duplicatePropertyNames(duplicates) { return createError('Object pattern has duplicate property names: ' + duplicates.join(', ')); } // ----------------- constructors ----------------- function invalidConstructorCall(grammar, ctorName, children) { return createError( 'Attempt to invoke constructor ' + ctorName + ' with invalid or unexpected arguments'); } // ----------------- convenience ----------------- function multipleErrors(errors) { var messages = errors.map(function(e) { return e.message; }); return createError( ['Errors:'].concat(messages).join('\n- '), errors[0].interval); } // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = { applicationOfSyntacticRuleFromLexicalContext: applicationOfSyntacticRuleFromLexicalContext, cannotExtendUndeclaredRule: cannotExtendUndeclaredRule, cannotOverrideUndeclaredRule: cannotOverrideUndeclaredRule, duplicateGrammarDeclaration: duplicateGrammarDeclaration, duplicateParameterNames: duplicateParameterNames, duplicatePropertyNames: duplicatePropertyNames, duplicateRuleDeclaration: duplicateRuleDeclaration, exprMixesValueAndStringExpressions: exprMixesValueAndStringExpressions, inconsistentArity: inconsistentArity, intervalSourcesDontMatch: intervalSourcesDontMatch, invalidConstructorCall: invalidConstructorCall, invalidParameter: invalidParameter, grammarSyntaxError: grammarSyntaxError, kleeneExprHasNullableOperand: kleeneExprHasNullableOperand, undeclaredGrammar: undeclaredGrammar, undeclaredRule: undeclaredRule, wrongNumberOfArguments: wrongNumberOfArguments, wrongNumberOfParameters: wrongNumberOfParameters, throwErrors: function(errors) { if (errors.length === 1) { throw errors[0]; } if (errors.length > 1) { throw multipleErrors(errors); } } }; },{"./Namespace":43}],50:[function(require,module,exports){ /* global document, XMLHttpRequest */ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var Builder = require('./Builder'); var Grammar = require('./Grammar'); var Namespace = require('./Namespace'); var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); var util = require('./util'); var isBuffer = require('is-buffer'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- // The metagrammar, i.e. the grammar for Ohm grammars. Initialized at the // bottom of this file because loading the grammar requires Ohm itself. var ohmGrammar; // An object which makes it possible to stub out the document API for testing. var documentInterface = { querySelector: function(sel) { return document.querySelector(sel); }, querySelectorAll: function(sel) { return document.querySelectorAll(sel); } }; // Check if `obj` is a DOM element. function isElement(obj) { return !!(obj && obj.nodeType === 1); } function isUndefined(obj) { return obj === void 0; } var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1; function isArrayLike(obj) { if (obj == null) { return false; } var length = obj.length; return typeof length === 'number' && length >= 0 && length <= MAX_ARRAY_INDEX; } // TODO: just use the jQuery thing function load(url) { var req = new XMLHttpRequest(); req.open('GET', url, false); try { req.send(); if (req.status === 0 || req.status === 200) { return req.responseText; } } catch (e) {} throw new Error('unable to load url ' + url); } // Returns a Grammar instance (i.e., an object with a `match` method) for // `tree`, which is the concrete syntax tree of a user-written grammar. // The grammar will be assigned into `namespace` under the name of the grammar // as specified in the source. function buildGrammar(match, namespace, optOhmGrammarForTesting) { var builder = new Builder(); var decl; var currentRuleName; var currentRuleFormals; var overriding = false; var metaGrammar = optOhmGrammarForTesting || ohmGrammar; // A visitor that produces a Grammar instance from the CST. var helpers = metaGrammar.semantics().addOperation('visit', { Grammar: function(n, s, open, rs, close) { var grammarName = n.visit(); decl = builder.newGrammar(grammarName, namespace); s.visit(); rs.visit(); var g = decl.build(); g.definitionInterval = this.interval.trimmed(); if (grammarName in namespace) { throw errors.duplicateGrammarDeclaration(g, namespace); } namespace[grammarName] = g; return g; }, SuperGrammar: function(_, n) { var superGrammarName = n.visit(); if (superGrammarName === 'null') { decl.withSuperGrammar(null); } else { if (!namespace || !(superGrammarName in namespace)) { throw errors.undeclaredGrammar(superGrammarName, namespace, n.interval); } decl.withSuperGrammar(namespace[superGrammarName]); } }, Rule_define: function(n, fs, d, _equals, _optBar, b) { currentRuleName = n.visit(); currentRuleFormals = fs.visit()[0] || []; // If there is no default start rule yet, set it now. This must be done before visiting // the body, because it might contain an inline rule definition. if (!decl.defaultStartRule && decl.ensureSuperGrammar() !== Grammar.ProtoBuiltInRules) { decl.withDefaultStartRule(currentRuleName); } var body = b.visit(); body.definitionInterval = this.interval.trimmed(); var description = d.visit()[0]; return decl.define(currentRuleName, currentRuleFormals, body, description); }, Rule_override: function(n, fs, _colonEquals, _optBar, b) { currentRuleName = n.visit(); currentRuleFormals = fs.visit()[0] || []; overriding = true; var body = b.visit(); body.definitionInterval = this.interval.trimmed(); var ans = decl.override(currentRuleName, currentRuleFormals, body); overriding = false; return ans; }, Rule_extend: function(n, fs, _plusEquals, _optBar, b) { currentRuleName = n.visit(); currentRuleFormals = fs.visit()[0] || []; var body = b.visit(); var ans = decl.extend(currentRuleName, currentRuleFormals, body); decl.ruleBodies[currentRuleName].definitionInterval = this.interval.trimmed(); return ans; }, Formals: function(opointy, fs, cpointy) { return fs.visit(); }, Params: function(opointy, ps, cpointy) { return ps.visit(); }, Alt: function(term, _, terms) { var args = [term.visit()].concat(terms.visit()); return builder.alt.apply(builder, args).withInterval(this.interval); }, Term_inline: function(b, n) { var inlineRuleName = currentRuleName + '_' + n.visit(); var body = b.visit(); body.definitionInterval = this.interval.trimmed(); var isNewRuleDeclaration = !(decl.superGrammar && decl.superGrammar.ruleBodies[inlineRuleName]); if (overriding && !isNewRuleDeclaration) { decl.override(inlineRuleName, currentRuleFormals, body); } else { decl.define(inlineRuleName, currentRuleFormals, body); } var params = currentRuleFormals.map(function(formal) { return builder.app(formal); }); return builder.app(inlineRuleName, params).withInterval(body.interval); }, Seq: function(expr) { return builder.seq.apply(builder, expr.visit()).withInterval(this.interval); }, Iter_star: function(x, _) { return builder.star(x.visit()).withInterval(this.interval); }, Iter_plus: function(x, _) { return builder.plus(x.visit()).withInterval(this.interval); }, Iter_opt: function(x, _) { return builder.opt(x.visit()).withInterval(this.interval); }, Pred_not: function(_, x) { return builder.not(x.visit()).withInterval(this.interval); }, Pred_lookahead: function(_, x) { return builder.la(x.visit()).withInterval(this.interval); }, Modifier_lex: function(_, x) { return builder.lex(x.visit()).withInterval(this.interval); }, Modifier_val: function(_, x) { return builder.val(x.visit()).withInterval(this.interval); }, Base_application: function(rule, ps) { return builder.app(rule.visit(), ps.visit()[0] || []).withInterval(this.interval); }, Base_range: function(from, _, to) { return builder.range(from.visit(), to.visit()).withInterval(this.interval); }, Base_prim: function(expr) { return builder.prim(expr.visit()).withInterval(this.interval); }, Base_paren: function(open, x, close) { return x.visit(); }, Base_arr: function(open, x, close) { return builder.arr(x.visit()).withInterval(this.interval); }, Base_obj: function(open, lenient, close) { return builder.obj([], lenient.visit()[0]); }, Base_objWithProps: function(open, ps, _, lenient, close) { return builder.obj(ps.visit(), lenient.visit()[0]).withInterval(this.interval); }, Props: function(p, _, ps) { return [p.visit()].concat(ps.visit()); }, Prop: function(n, _, p) { return {name: n.visit(), pattern: p.visit()}; }, ruleDescr: function(open, t, close) { return t.visit(); }, ruleDescrText: function(_) { return this.interval.contents.trim(); }, caseName: function(_, space1, n, space2, end) { return n.visit(); }, name: function(first, rest) { return this.interval.contents; }, nameFirst: function(expr) {}, nameRest: function(expr) {}, keyword_null: function(_) { return null; }, keyword_true: function(_) { return true; }, keyword_false: function(_) { return false; }, string: function(open, cs, close) { return cs.visit().map(function(c) { return common.unescapeChar(c); }).join(''); }, strChar: function(_) { return this.interval.contents; }, escapeChar: function(_) { return this.interval.contents; }, number: function(_, digits) { return parseInt(this.interval.contents); }, NonemptyListOf: function(x, _, xs) { return [x.visit()].concat(xs.visit()); }, EmptyListOf: function() { return []; } }); return helpers(match).visit(); } function compileAndLoad(source, namespace) { var m = ohmGrammar.match(source, 'Grammars'); if (m.failed()) { throw errors.grammarSyntaxError(m); } return buildGrammar(m, namespace); } // Return the contents of a script element, fetching it via XHR if necessary. function getScriptElementContents(el) { if (!isElement(el)) { throw new TypeError('Expected a DOM Node, got ' + common.unexpectedObjToString(el)); } if (el.type !== 'text/ohm-js') { throw new Error('Expected a script tag with type="text/ohm-js", got ' + el); } return el.getAttribute('src') ? load(el.getAttribute('src')) : el.innerHTML; } function grammar(source, optNamespace) { var ns = grammars(source, optNamespace); // Ensure that the source contained no more than one grammar definition. var grammarNames = Object.keys(ns); if (grammarNames.length === 0) { throw new Error('Missing grammar definition'); } else if (grammarNames.length > 1) { var secondGrammar = ns[grammarNames[1]]; var interval = secondGrammar.definitionInterval; throw new Error( util.getLineAndColumnMessage(interval.inputStream.source, interval.startIdx) + 'Found more than one grammar definition -- use ohm.grammars() instead.'); } return ns[grammarNames[0]]; // Return the one and only grammar. } function grammars(source, optNamespace) { var ns = Namespace.extend(Namespace.asNamespace(optNamespace)); if (typeof source !== 'string') { // For convenience, detect Node.js Buffer objects and automatically call toString(). if (isBuffer(source)) { source = source.toString(); } else { throw new TypeError( 'Expected string as first argument, got ' + common.unexpectedObjToString(source)); } } compileAndLoad(source, ns); return ns; } function grammarFromScriptElement(optNode) { var node = optNode; if (isUndefined(node)) { var nodeList = documentInterface.querySelectorAll('script[type="text/ohm-js"]'); if (nodeList.length !== 1) { throw new Error( 'Expected exactly one script tag with type="text/ohm-js", found ' + nodeList.length); } node = nodeList[0]; } return grammar(getScriptElementContents(node)); } function grammarsFromScriptElements(optNodeOrNodeList) { // Simple case: the argument is a DOM node. if (isElement(optNodeOrNodeList)) { return grammars(optNodeOrNodeList); } // Otherwise, it must be either undefined or a NodeList. var nodeList = optNodeOrNodeList; if (isUndefined(nodeList)) { // Find all script elements with type="text/ohm-js". nodeList = documentInterface.querySelectorAll('script[type="text/ohm-js"]'); } else if (typeof nodeList === 'string' || (!isElement(nodeList) && !isArrayLike(nodeList))) { throw new TypeError('Expected a Node, NodeList, or Array, but got ' + nodeList); } var ns = Namespace.createNamespace(); for (var i = 0; i < nodeList.length; ++i) { // Copy the new grammars into `ns` to keep the namespace flat. common.extend(ns, grammars(getScriptElementContents(nodeList[i]), ns)); } return ns; } function makeRecipe(recipeFn) { return recipeFn.call(new Builder()); } // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- // Stuff that users should know about module.exports = { createNamespace: Namespace.createNamespace, grammar: grammar, grammars: grammars, grammarFromScriptElement: grammarFromScriptElement, grammarsFromScriptElements: grammarsFromScriptElements, makeRecipe: makeRecipe, ohmGrammar: null, // Initialized below, after Grammar.BuiltInRules. pexprs: pexprs, util: util, extras: require('../extras') }; // Stuff for testing, etc. module.exports._buildGrammar = buildGrammar; module.exports._setDocumentInterfaceForTesting = function(doc) { documentInterface = doc; }; // Late initialization for stuff that is bootstrapped. Grammar.BuiltInRules = require('../dist/built-in-rules'); var Semantics = require('./Semantics'); var operationsAndAttributesGrammar = require('../dist/operations-and-attributes'); Semantics.initBuiltInSemantics(Grammar.BuiltInRules); Semantics.initPrototypeParser(operationsAndAttributesGrammar); // requires BuiltInSemantics module.exports.ohmGrammar = ohmGrammar = require('../dist/ohm-grammar'); Grammar.initStartRuleParser(ohmGrammar, buildGrammar); },{"../dist/built-in-rules":10,"../dist/ohm-grammar":11,"../dist/operations-and-attributes":12,"../extras":13,"./Builder":36,"./Grammar":38,"./Namespace":43,"./Semantics":45,"./common":48,"./errors":49,"./pexprs":67,"./util":68,"is-buffer":34}],51:[function(require,module,exports){ 'use strict'; var inherits = require('inherits'); var common = require('./common'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function Node(grammar, ctorName, children, interval) { this.grammar = grammar; this.ctorName = ctorName; this.children = children; this.interval = interval; } Node.prototype.numChildren = function() { return this.children.length; }; Node.prototype.childAt = function(idx) { return this.children[idx]; }; Node.prototype.indexOfChild = function(arg) { return this.children.indexOf(arg); }; Node.prototype.hasChildren = function() { return this.children.length > 0; }; Node.prototype.hasNoChildren = function() { return !this.hasChildren(); }; Node.prototype.onlyChild = function() { if (this.children.length !== 1) { throw new Error( 'cannot get only child of a node of type ' + this.ctorName + ' (it has ' + this.numChildren() + ' children)'); } else { return this.firstChild(); } }; Node.prototype.firstChild = function() { if (this.hasNoChildren()) { throw new Error( 'cannot get first child of a ' + this.ctorName + ' node, which has no children'); } else { return this.childAt(0); } }; Node.prototype.lastChild = function() { if (this.hasNoChildren()) { throw new Error( 'cannot get last child of a ' + this.ctorName + ' node, which has no children'); } else { return this.childAt(this.numChildren() - 1); } }; Node.prototype.childBefore = function(child) { var childIdx = this.indexOfChild(child); if (childIdx < 0) { throw new Error('Node.childBefore() called w/ an argument that is not a child'); } else if (childIdx === 0) { throw new Error('cannot get child before first child'); } else { return this.childAt(childIdx - 1); } }; Node.prototype.childAfter = function(child) { var childIdx = this.indexOfChild(child); if (childIdx < 0) { throw new Error('Node.childAfter() called w/ an argument that is not a child'); } else if (childIdx === this.numChildren() - 1) { throw new Error('cannot get child after last child'); } else { return this.childAt(childIdx + 1); } }; Node.prototype.isTerminal = function() { return false; }; Node.prototype.isNonterminal = function() { return false; }; Node.prototype.isIteration = function() { return false; }; Node.prototype.isOptional = function() { return false; }; Node.prototype.toJSON = function() { var r = {}; r[this.ctorName] = this.children; return r; }; // Terminals function TerminalNode(grammar, value, interval) { Node.call(this, grammar, '_terminal', [], interval); this.primitiveValue = value; } inherits(TerminalNode, Node); TerminalNode.prototype.isTerminal = function() { return true; }; // Nonterminals function NonterminalNode(grammar, ruleName, children, interval) { Node.call(this, grammar, ruleName, children, interval); } inherits(NonterminalNode, Node); NonterminalNode.prototype.isNonterminal = function() { return true; }; NonterminalNode.prototype.isLexical = function() { return common.isLexical(this.ctorName); }; NonterminalNode.prototype.isSyntactic = function() { return common.isSyntactic(this.ctorName); }; // Iterations function IterationNode(grammar, children, interval, optional) { Node.call(this, grammar, '_iter', children, interval); this.optional = optional; } inherits(IterationNode, Node); IterationNode.prototype.isIteration = function() { return true; }; IterationNode.prototype.isOptional = function() { return this.optional; }; // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- module.exports = { Node: Node, TerminalNode: TerminalNode, NonterminalNode: NonterminalNode, IterationNode: IterationNode }; },{"./common":48,"inherits":33}],52:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- var lexifyCount; pexprs.PExpr.prototype.assertAllApplicationsAreValid = function(ruleName, grammar) { lexifyCount = 0; this._assertAllApplicationsAreValid(ruleName, grammar); }; pexprs.PExpr.prototype._assertAllApplicationsAreValid = common.abstract; pexprs.any._assertAllApplicationsAreValid = pexprs.end._assertAllApplicationsAreValid = pexprs.Prim.prototype._assertAllApplicationsAreValid = pexprs.Range.prototype._assertAllApplicationsAreValid = pexprs.Param.prototype._assertAllApplicationsAreValid = pexprs.TypeCheck.prototype._assertAllApplicationsAreValid = pexprs.UnicodeChar.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { // no-op }; pexprs.Lex.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { lexifyCount++; this.expr._assertAllApplicationsAreValid(ruleName, grammar); lexifyCount--; }; pexprs.Alt.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { for (var idx = 0; idx < this.terms.length; idx++) { this.terms[idx]._assertAllApplicationsAreValid(ruleName, grammar); } }; pexprs.Seq.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { for (var idx = 0; idx < this.factors.length; idx++) { this.factors[idx]._assertAllApplicationsAreValid(ruleName, grammar); } }; pexprs.Iter.prototype._assertAllApplicationsAreValid = pexprs.Not.prototype._assertAllApplicationsAreValid = pexprs.Lookahead.prototype._assertAllApplicationsAreValid = pexprs.Value.prototype._assertAllApplicationsAreValid = pexprs.Arr.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { this.expr._assertAllApplicationsAreValid(ruleName, grammar); }; pexprs.Obj.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { for (var idx = 0; idx < this.properties.length; idx++) { this.properties[idx].pattern._assertAllApplicationsAreValid(ruleName, grammar); } }; pexprs.Apply.prototype._assertAllApplicationsAreValid = function(ruleName, grammar) { var body = grammar.ruleBodies[this.ruleName]; // Make sure that the rule exists... if (!body) { throw errors.undeclaredRule(this.ruleName, grammar.name, this.interval); } // ...and that this application is allowed if (common.isSyntactic(this.ruleName) && (!common.isSyntactic(ruleName) || lexifyCount > 0)) { throw errors.applicationOfSyntacticRuleFromLexicalContext(this.ruleName, this); } // ...and that this application has the correct number of arguments var actual = this.args.length; var expected = grammar.ruleFormals[this.ruleName].length; if (actual !== expected) { throw errors.wrongNumberOfArguments(this.ruleName, expected, actual, this); } // ...and that all of the argument expressions only have valid applications and have arity 1. var self = this; this.args.forEach(function(arg) { arg._assertAllApplicationsAreValid(ruleName, grammar); if (arg.getArity() !== 1) { throw errors.invalidParameter(self.ruleName, arg); } }); }; },{"./common":48,"./errors":49,"./pexprs":67}],53:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- pexprs.PExpr.prototype.assertChoicesHaveUniformArity = common.abstract; pexprs.any.assertChoicesHaveUniformArity = pexprs.end.assertChoicesHaveUniformArity = pexprs.Prim.prototype.assertChoicesHaveUniformArity = pexprs.Range.prototype.assertChoicesHaveUniformArity = pexprs.Param.prototype.assertChoicesHaveUniformArity = pexprs.Lex.prototype.assertChoicesHaveUniformArity = pexprs.TypeCheck.prototype.assertChoicesHaveUniformArity = pexprs.UnicodeChar.prototype.assertChoicesHaveUniformArity = function(ruleName) { // no-op }; pexprs.Alt.prototype.assertChoicesHaveUniformArity = function(ruleName) { if (this.terms.length === 0) { return; } var arity = this.terms[0].getArity(); for (var idx = 0; idx < this.terms.length; idx++) { var term = this.terms[idx]; term.assertChoicesHaveUniformArity(); var otherArity = term.getArity(); if (arity !== otherArity) { throw errors.inconsistentArity(ruleName, arity, otherArity, term); } } }; pexprs.Extend.prototype.assertChoicesHaveUniformArity = function(ruleName) { // Extend is a special case of Alt that's guaranteed to have exactly two // cases: [extensions, origBody]. var actualArity = this.terms[0].getArity(); var expectedArity = this.terms[1].getArity(); if (actualArity !== expectedArity) { throw errors.inconsistentArity(ruleName, expectedArity, actualArity, this.terms[0]); } }; pexprs.Seq.prototype.assertChoicesHaveUniformArity = function(ruleName) { for (var idx = 0; idx < this.factors.length; idx++) { this.factors[idx].assertChoicesHaveUniformArity(ruleName); } }; pexprs.Iter.prototype.assertChoicesHaveUniformArity = function(ruleName) { this.expr.assertChoicesHaveUniformArity(ruleName); }; pexprs.Not.prototype.assertChoicesHaveUniformArity = function(ruleName) { // no-op (not required b/c the nested expr doesn't show up in the CST) }; pexprs.Lookahead.prototype.assertChoicesHaveUniformArity = pexprs.Arr.prototype.assertChoicesHaveUniformArity = pexprs.Value.prototype.assertChoicesHaveUniformArity = function(ruleName) { this.expr.assertChoicesHaveUniformArity(ruleName); }; pexprs.Obj.prototype.assertChoicesHaveUniformArity = function(ruleName) { for (var idx = 0; idx < this.properties.length; idx++) { this.properties[idx].pattern.assertChoicesHaveUniformArity(ruleName); } }; pexprs.Apply.prototype.assertChoicesHaveUniformArity = function(ruleName) { // The arities of the parameter expressions is required to be 1 by // `assertAllApplicationsAreValid()`. }; },{"./common":48,"./errors":49,"./pexprs":67}],54:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- pexprs.PExpr.prototype.assertIteratedExprsAreNotNullable = common.abstract; pexprs.any.assertIteratedExprsAreNotNullable = pexprs.end.assertIteratedExprsAreNotNullable = pexprs.Prim.prototype.assertIteratedExprsAreNotNullable = pexprs.Range.prototype.assertIteratedExprsAreNotNullable = pexprs.Param.prototype.assertIteratedExprsAreNotNullable = pexprs.TypeCheck.prototype.assertIteratedExprsAreNotNullable = pexprs.UnicodeChar.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { // no-op }; pexprs.Alt.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { for (var idx = 0; idx < this.terms.length; idx++) { this.terms[idx].assertIteratedExprsAreNotNullable(grammar, ruleName); } }; pexprs.Seq.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { for (var idx = 0; idx < this.factors.length; idx++) { this.factors[idx].assertIteratedExprsAreNotNullable(grammar, ruleName); } }; pexprs.Iter.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { // Note: this is the implementation of this method for `Star` and `Plus` expressions. // It is overridden for `Opt` below. this.expr.assertIteratedExprsAreNotNullable(grammar, ruleName); if (this.expr.isNullable(grammar)) { throw errors.kleeneExprHasNullableOperand(this, ruleName); } }; pexprs.Opt.prototype.assertIteratedExprsAreNotNullable = pexprs.Not.prototype.assertIteratedExprsAreNotNullable = pexprs.Lookahead.prototype.assertIteratedExprsAreNotNullable = pexprs.Lex.prototype.assertIteratedExprsAreNotNullable = pexprs.Value.prototype.assertIteratedExprsAreNotNullable = pexprs.Arr.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { this.expr.assertIteratedExprsAreNotNullable(grammar, ruleName); }; pexprs.Obj.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { for (var idx = 0; idx < this.properties.length; idx++) { this.properties[idx].pattern.assertIteratedExprsAreNotNullable(grammar, ruleName); } }; pexprs.Apply.prototype.assertIteratedExprsAreNotNullable = function(grammar, ruleName) { this.args.forEach(function(arg) { arg.assertIteratedExprsAreNotNullable(grammar, ruleName); }); }; },{"./common":48,"./errors":49,"./pexprs":67}],55:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- // Checks that no PExpr combines a value expression (e.g., `null`, `3`) with a string fragment // expression (e.g., `"blah"`). pexprs.PExpr.prototype.assertValuesAndStringsAreNotMixed = function(grammar, ruleName) { var memo = Object.create(null); memo[ruleName] = pexprs.TYPE_ANY; // Initialize memo table for the rule we are checking. this.getExprType(grammar, memo); }; },{"./pexprs":67}],56:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var nodes = require('./nodes'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- pexprs.PExpr.prototype.check = common.abstract; pexprs.any.check = function(grammar, vals) { return vals.length >= 1; }; pexprs.end.check = function(grammar, vals) { return vals[0] instanceof nodes.Node && vals[0].isTerminal() && vals[0].primitiveValue === undefined; }; pexprs.Prim.prototype.check = function(grammar, vals) { return vals[0] instanceof nodes.Node && vals[0].isTerminal() && vals[0].primitiveValue === this.obj; }; pexprs.Range.prototype.check = function(grammar, vals) { return vals[0] instanceof nodes.Node && vals[0].isTerminal() && typeof vals[0].primitiveValue === typeof this.from; }; pexprs.Param.prototype.check = function(grammar, vals) { return vals.length >= 1; }; pexprs.Alt.prototype.check = function(grammar, vals) { for (var i = 0; i < this.terms.length; i++) { var term = this.terms[i]; if (term.check(grammar, vals)) { return true; } } return false; }; pexprs.Seq.prototype.check = function(grammar, vals) { var pos = 0; for (var i = 0; i < this.factors.length; i++) { var factor = this.factors[i]; if (factor.check(grammar, vals.slice(pos))) { pos += factor.getArity(); } else { return false; } } return true; }; pexprs.Iter.prototype.check = function(grammar, vals) { var arity = this.getArity(); var columns = vals.slice(0, arity); if (columns.length !== arity) { return false; } var rowCount = columns[0].length; var i; for (i = 1; i < arity; i++) { if (columns[i].length !== rowCount) { return false; } } for (i = 0; i < rowCount; i++) { var row = []; for (var j = 0; j < arity; j++) { row.push(columns[j][i]); } if (!this.expr.check(grammar, row)) { return false; } } return true; }; pexprs.Not.prototype.check = function(grammar, vals) { return true; }; pexprs.Lookahead.prototype.check = pexprs.Lex.prototype.check = pexprs.Value.prototype.check = pexprs.Arr.prototype.check = function(grammar, vals) { return this.expr.check(grammar, vals); }; pexprs.Obj.prototype.check = function(grammar, vals) { var fixedArity = this.getArity(); if (this.isLenient) { fixedArity--; } var pos = 0; for (var i = 0; i < fixedArity; i++) { var pattern = this.properties[i].pattern; if (pattern.check(grammar, vals.slice(pos))) { pos += pattern.getArity(); } else { return false; } } return this.isLenient ? typeof vals[pos] === 'object' && vals[pos] : true; }; pexprs.Apply.prototype.check = function(grammar, vals) { if (!(vals[0] instanceof nodes.Node && vals[0].grammar === grammar && vals[0].ctorName === this.ruleName)) { return false; } // TODO: think about *not* doing the following checks, i.e., trusting that the rule // was correctly constructed. var ruleNode = vals[0]; var body = grammar.ruleBodies[this.ruleName]; return body.check(grammar, ruleNode.children) && ruleNode.numChildren() === body.getArity(); }; pexprs.UnicodeChar.prototype.check = function(grammar, vals) { return vals[0] instanceof nodes.Node && vals[0].isTerminal() && typeof vals[0].primitiveValue === 'string'; }; pexprs.TypeCheck.prototype.check = function(grammar, vals) { return vals[0] instanceof nodes.Node && typeof vals[0].primitiveValue === this.type; }; },{"./common":48,"./nodes":51,"./pexprs":67}],57:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var InputStream = require('./InputStream'); var Trace = require('./Trace'); var common = require('./common'); var nodes = require('./nodes'); var pexprs = require('./pexprs'); var TerminalNode = nodes.TerminalNode; var NonterminalNode = nodes.NonterminalNode; var IterationNode = nodes.IterationNode; // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- // A safer version of hasOwnProperty. var hasOwnProp = Object.prototype.hasOwnProperty; /* Evaluate the expression and return `true` if it succeeds, `false` otherwise. This method should only be called directly by `State.prototype.eval(expr)`, which also updates the data structures that are used for tracing. (Making those updates in a method of `State` enables the trace-specific data structures to be "secrets" of that class, which is good for modularity.) The contract of this method is as follows: * When the return value is `true`, - the state object will have `expr.getArity()` more bindings than it did before the call. * When the return value is `false`, - the state object may have more bindings than it did before the call, and - its input stream's position may be anywhere. Note that `State.prototype.eval(expr)`, unlike this method, guarantees that neither the state object's bindings nor its input stream's position will change if the expression fails to match. */ pexprs.PExpr.prototype.eval = common.abstract; // function(state) { ... } pexprs.any.eval = function(state) { var origPos = state.skipSpacesIfInSyntacticContext(); var inputStream = state.inputStream; var value = inputStream.next(); if (value === common.fail) { state.processFailure(origPos, this); return false; } else { var interval = inputStream.interval(origPos); state.bindings.push(new TerminalNode(state.grammar, value, interval)); return true; } }; pexprs.end.eval = function(state) { var origPos = state.skipSpacesIfInSyntacticContext(); var inputStream = state.inputStream; if (inputStream.atEnd()) { var interval = inputStream.interval(inputStream.pos); state.bindings.push(new TerminalNode(state.grammar, undefined, interval)); return true; } else { state.processFailure(origPos, this); return false; } }; pexprs.Prim.prototype.eval = function(state) { var origPos = state.skipSpacesIfInSyntacticContext(); var inputStream = state.inputStream; if (this.match(inputStream) === common.fail) { state.processFailure(origPos, this); return false; } else { var interval = inputStream.interval(origPos); var primitiveValue = this.obj; state.bindings.push(new TerminalNode(state.grammar, primitiveValue, interval)); return true; } }; pexprs.Prim.prototype.match = function(inputStream) { return typeof this.obj === 'string' ? inputStream.matchString(this.obj) : inputStream.matchExactly(this.obj); }; pexprs.Range.prototype.eval = function(state) { var origPos = state.skipSpacesIfInSyntacticContext(); var inputStream = state.inputStream; var obj = inputStream.next(); if (typeof obj === typeof this.from && this.from <= obj && obj <= this.to) { var interval = inputStream.interval(origPos); state.bindings.push(new TerminalNode(state.grammar, obj, interval)); return true; } else { state.processFailure(origPos, this); return false; } }; pexprs.Param.prototype.eval = function(state) { return state.eval(state.currentApplication().args[this.index]); }; pexprs.Lex.prototype.eval = function(state) { state.enterLexifiedContext(); var ans = state.eval(this.expr); state.exitLexifiedContext(); return ans; }; pexprs.Alt.prototype.eval = function(state) { for (var idx = 0; idx < this.terms.length; idx++) { if (state.eval(this.terms[idx])) { return true; } } return false; }; pexprs.Seq.prototype.eval = function(state) { for (var idx = 0; idx < this.factors.length; idx++) { var factor = this.factors[idx]; if (!state.eval(factor)) { return false; } } return true; }; pexprs.Iter.prototype.eval = function(state) { var inputStream = state.inputStream; var origPos = inputStream.pos; var arity = this.getArity(); var cols = []; while (cols.length < arity) { cols.push([]); } var numMatches = 0; var idx; while (numMatches < this.maxNumMatches && state.eval(this.expr)) { numMatches++; var row = state.bindings.splice(state.bindings.length - arity, arity); for (idx = 0; idx < row.length; idx++) { cols[idx].push(row[idx]); } } if (numMatches < this.minNumMatches) { return false; } var interval; if (numMatches === 0) { interval = inputStream.interval(origPos, origPos); } else { var firstCol = cols[0]; var lastCol = cols[cols.length - 1]; interval = inputStream.interval( firstCol[0].interval.startIdx, lastCol[lastCol.length - 1].interval.endIdx); } for (idx = 0; idx < cols.length; idx++) { state.bindings.push(new IterationNode(state.grammar, cols[idx], interval, this instanceof pexprs.Opt)); } return true; }; pexprs.Not.prototype.eval = function(state) { /* TODO: - Right now we're just throwing away all of the failures that happen inside a `not`, and recording `this` as a failed expression. - Double negation should be equivalent to lookahead, but that's not the case right now wrt failures. E.g., ~~'foo' produces a failure for ~~'foo', but maybe it should produce a failure for 'foo' instead. */ var inputStream = state.inputStream; var origPos = inputStream.pos; var failuresInfo = state.getFailuresInfo(); var ans = state.eval(this.expr); state.restoreFailuresInfo(failuresInfo); if (ans) { state.processFailure(origPos, this); return false; } inputStream.pos = origPos; return true; }; pexprs.Lookahead.prototype.eval = function(state) { var inputStream = state.inputStream; var origPos = inputStream.pos; if (state.eval(this.expr)) { inputStream.pos = origPos; return true; } else { return false; } }; pexprs.Arr.prototype.eval = function(state) { var obj = state.inputStream.next(); if (Array.isArray(obj)) { state.pushInputStream(InputStream.newFor(obj)); var ans = state.eval(this.expr) && state.inputStream.atEnd(); state.popInputStream(); return ans; } else { return false; } }; pexprs.Value.prototype.eval = function(state) { var obj = state.inputStream.next(); if (typeof obj === 'string') { state.pushInputStream(InputStream.newFor(obj)); var ans = state.eval(this.expr) && state.inputStream.atEnd(); state.popInputStream(); return ans; } else { return false; } }; pexprs.Obj.prototype.eval = function(state) { var inputStream = state.inputStream; var origPos = inputStream.pos; var obj = inputStream.next(); if (obj !== common.fail && obj && (typeof obj === 'object' || typeof obj === 'function')) { var numOwnPropertiesMatched = 0; for (var idx = 0; idx < this.properties.length; idx++) { var property = this.properties[idx]; if (!hasOwnProp.call(obj, property.name)) { return false; } var value = obj[property.name]; var expr = property.pattern; state.pushInputStream(expr.newInputStreamFor([value], state.grammar)); var matched = state.eval(expr) && state.inputStream.atEnd(); state.popInputStream(); if (!matched) { return false; } numOwnPropertiesMatched++; } if (this.isLenient) { var remainder = {}; for (var p in obj) { if (hasOwnProp.call(obj, p) && this.properties.indexOf(p) < 0) { remainder[p] = obj[p]; } } var interval = inputStream.interval(origPos); state.bindings.push(new TerminalNode(state.grammar, remainder, interval)); return true; } else { return numOwnPropertiesMatched === Object.keys(obj).length; } } else { return false; } }; pexprs.Apply.prototype.eval = function(state) { var caller = state.currentApplication(); var actuals = caller ? caller.args : []; var app = this.substituteParams(actuals); // Skip whitespace at the application site, if the rule that's being applied is syntactic if (app !== state.applySpaces && (app.isSyntactic() || state.inSyntacticContext())) { state.skipSpaces(); } var posInfo = state.getCurrentPosInfo(); if (posInfo.isActive(app)) { // This rule is already active at this position, i.e., it is left-recursive. return app.handleCycle(state); } var memoKey = app.toMemoKey(); var memoRec = posInfo.memo[memoKey]; return memoRec && posInfo.shouldUseMemoizedResult(memoRec) ? state.useMemoizedResult(memoRec) : app.reallyEval(state, !caller); }; pexprs.Apply.prototype.handleCycle = function(state) { var posInfo = state.getCurrentPosInfo(); var currentLeftRecursion = posInfo.currentLeftRecursion; var memoKey = this.toMemoKey(); var memoRec = posInfo.memo[memoKey]; if (currentLeftRecursion && currentLeftRecursion.headApplication.toMemoKey() === memoKey) { // We already know about this left recursion, but it's possible there are "involved // applications" that we don't already know about, so... memoRec.updateInvolvedApplicationMemoKeys(); } else if (!memoRec) { // New left recursion detected! Memoize a failure to try to get a seed parse. memoRec = posInfo.memo[memoKey] = {pos: -1, value: false}; posInfo.startLeftRecursion(this, memoRec); } return state.useMemoizedResult(memoRec); }; pexprs.Apply.prototype.reallyEval = function(state, isTopLevelApplication) { var inputStream = state.inputStream; var origPos = inputStream.pos; var origPosInfo = state.getCurrentPosInfo(); var body = state.grammar.ruleBodies[this.ruleName]; var description = state.grammar.ruleDescriptions[this.ruleName]; origPosInfo.enter(this); if (description) { var origFailuresInfo = state.getFailuresInfo(); } var value = this.evalOnce(body, state); var currentLR = origPosInfo.currentLeftRecursion; var memoKey = this.toMemoKey(); var isHeadOfLeftRecursion = currentLR && currentLR.headApplication.toMemoKey() === memoKey; var memoized = true; if (isHeadOfLeftRecursion) { value = this.growSeedResult(body, state, origPos, currentLR, value); origPosInfo.endLeftRecursion(); } else if (currentLR && currentLR.isInvolved(memoKey)) { // Don't memoize the result memoized = false; } else { origPosInfo.memo[memoKey] = { pos: inputStream.pos, value: value, failuresAtRightmostPosition: state.cloneRightmostFailures() }; } if (description) { state.restoreFailuresInfo(origFailuresInfo); if (!value) { state.processFailure(origPos, this); } if (memoized) { origPosInfo.memo[memoKey].failuresAtRightmostPosition = state.cloneRightmostFailures(); } } // Record trace information in the memo table, so that it is available if the memoized result // is used later. if (state.isTracing() && origPosInfo.memo[memoKey]) { var entry = state.getTraceEntry(origPos, this, value); entry.setLeftRecursive(isHeadOfLeftRecursion); origPosInfo.memo[memoKey].traceEntry = entry; } origPosInfo.exit(); if (value) { state.bindings.push(value); return !isTopLevelApplication || this.entireInputWasConsumed(state); } else { return false; } }; pexprs.Apply.prototype.evalOnce = function(expr, state) { var inputStream = state.inputStream; var origPos = inputStream.pos; // If `matchNodes` is true and the next thing in the input stream is a Node whose type matches // this rule, then accept that as a valid match -- but not for the top-level application. if (state.matchNodes && state.applicationStack.length > 1) { var node = inputStream.next(); if (node instanceof nodes.Node && node.grammar === state.grammar && node.ctorName === this.ruleName) { return node; } else { inputStream.pos = origPos; } } if (state.eval(expr)) { var arity = expr.getArity(); var bindings = state.bindings.splice(state.bindings.length - arity, arity); var ans = new NonterminalNode(state.grammar, this.ruleName, bindings, inputStream.interval(origPos)); return ans; } else { return false; } }; pexprs.Apply.prototype.growSeedResult = function(body, state, origPos, lrMemoRec, newValue) { if (!newValue) { return false; } var inputStream = state.inputStream; while (true) { lrMemoRec.pos = inputStream.pos; lrMemoRec.value = newValue; lrMemoRec.failuresAtRightmostPosition = state.cloneRightmostFailures(); if (state.isTracing()) { var children = state.trace[state.trace.length - 1].children.slice(); lrMemoRec.traceEntry = new Trace(state.inputStream, origPos, this, newValue, children); } inputStream.pos = origPos; newValue = this.evalOnce(body, state); if (inputStream.pos <= lrMemoRec.pos) { break; } } if (state.isTracing()) { state.trace.pop(); // Drop last trace entry since `value` was unused. lrMemoRec.traceEntry = null; } inputStream.pos = lrMemoRec.pos; return lrMemoRec.value; }; pexprs.Apply.prototype.entireInputWasConsumed = function(state) { if (this.isSyntactic()) { state.skipSpaces(); } if (!state.eval(pexprs.end)) { return false; } state.bindings.pop(); // discard the binding that was added by `end` in the check above return true; }; pexprs.UnicodeChar.prototype.eval = function(state) { var origPos = state.skipSpacesIfInSyntacticContext(); var inputStream = state.inputStream; var value = inputStream.next(); if (value === common.fail || !this.pattern.test(value)) { state.processFailure(origPos, this); return false; } else { var interval = inputStream.interval(origPos); state.bindings.push(new TerminalNode(state.grammar, value, interval)); return true; } }; pexprs.TypeCheck.prototype.eval = function(state) { var inputStream = state.inputStream; var origPos = inputStream.pos; var value = inputStream.next(); if (typeof value === this.type) { var interval = inputStream.interval(origPos); state.bindings.push(new TerminalNode(state.grammar, value, interval)); return true; } else { state.processFailure(origPos, this); return false; } }; },{"./InputStream":40,"./Trace":47,"./common":48,"./nodes":51,"./pexprs":67}],58:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- pexprs.PExpr.prototype.getArity = common.abstract; pexprs.any.getArity = pexprs.end.getArity = pexprs.Prim.prototype.getArity = pexprs.Range.prototype.getArity = pexprs.Param.prototype.getArity = pexprs.Apply.prototype.getArity = pexprs.TypeCheck.prototype.getArity = pexprs.UnicodeChar.prototype.getArity = function() { return 1; }; pexprs.Alt.prototype.getArity = function() { // This is ok b/c all terms must have the same arity -- this property is // checked by the Grammar constructor. return this.terms.length === 0 ? 0 : this.terms[0].getArity(); }; pexprs.Seq.prototype.getArity = function() { var arity = 0; for (var idx = 0; idx < this.factors.length; idx++) { arity += this.factors[idx].getArity(); } return arity; }; pexprs.Iter.prototype.getArity = function() { return this.expr.getArity(); }; pexprs.Not.prototype.getArity = function() { return 0; }; pexprs.Lookahead.prototype.getArity = pexprs.Lex.prototype.getArity = pexprs.Value.prototype.getArity = pexprs.Arr.prototype.getArity = function() { return this.expr.getArity(); }; pexprs.Obj.prototype.getArity = function() { var arity = this.isLenient ? 1 : 0; for (var idx = 0; idx < this.properties.length; idx++) { arity += this.properties[idx].pattern.getArity(); } return arity; }; },{"./common":48,"./pexprs":67}],59:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var errors = require('./errors'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- function typeFromPrimitive(prim) { return typeof prim === 'string' ? pexprs.TYPE_STRING : pexprs.TYPE_VALUE; } /* Returns the type of this PExpr -- one of `TYPE_STRING`, `TYPE_VALUE`, or `TYPE_ANY`. String expressions (e.g. `"foo"`) and value expressions (e.g., `null`, `3`) cannot be combined with each other, but they may be combined with TYPE_ANY expressions. An exception is thrown if an expression with inconsistent types is encountered. The result of this method is cached as a property on the node. For rule applications, the result is cached in a separate memo table, so that the result can be shared for all `Apply` nodes having the same parameters. */ pexprs.PExpr.prototype.getExprType = function(grammar, optMemo) { if (!this.hasOwnProperty('_exprType')) { var memo = optMemo || Object.create(null); Object.defineProperty(this, '_exprType', { value: this._calculateExprType(grammar, memo) }); } return this._exprType; }; /* The actual implementation of getExprType, with no caching logic. These implementations should only be invoked directly by the implementation of getExprType above. */ pexprs.PExpr.prototype._calculateExprType = common.abstract; pexprs.any._calculateExprType = pexprs.UnicodeChar.prototype._calculateExprType = function(grammar, memo) { return pexprs.TYPE_STRING; }; pexprs.end._calculateExprType = function(grammar, memo) { return pexprs.TYPE_ANY; }; pexprs.Range.prototype._calculateExprType = function(grammar, memo) { return typeFromPrimitive(this.from) | typeFromPrimitive(this.to); }; pexprs.Arr.prototype._calculateExprType = pexprs.Obj.prototype._calculateExprType = pexprs.TypeCheck.prototype._calculateExprType = pexprs.Value.prototype._calculateExprType = function(grammar, memo) { return pexprs.TYPE_VALUE; }; pexprs.Prim.prototype._calculateExprType = function(grammar, memo) { return typeFromPrimitive(this.obj); }; pexprs.Alt.prototype._calculateExprType = function(grammar, memo) { var ans = this.terms.reduce(function(acc, t) { return acc | t.getExprType(grammar, memo); }, 0); if (ans === pexprs.TYPE_INCONSISTENT) { throw errors.exprMixesValueAndStringExpressions(this); } return ans; }; pexprs.Seq.prototype._calculateExprType = function(grammar, memo) { var ans = this.factors.reduce(function(acc, f) { return acc | f.getExprType(grammar, memo); }, 0); if (ans === pexprs.TYPE_INCONSISTENT) { throw errors.exprMixesValueAndStringExpressions(this); } return ans; }; pexprs.Iter.prototype._calculateExprType = pexprs.Not.prototype._calculateExprType = pexprs.Lookahead.prototype._calculateExprType = pexprs.Lex.prototype._calculateExprType = function(grammar, memo) { return this.expr.getExprType(grammar, memo); }; pexprs.Param.prototype._calculateExprType = function(grammar, memo) { // Throwing an error here ensures that we never calculate and cache the result of an // expression containing unbound parameters, because it could be incorrect. throw new Error('Cannot calculate _calculateExprType for unbound parameter'); }; pexprs.Apply.prototype._calculateExprType = function(grammar, memo) { var key = this.toMemoKey(); if (!Object.prototype.hasOwnProperty.call(memo, key)) { var inlinedBody = grammar.ruleBodies[this.ruleName].substituteParams(this.args); // Initialize a memo value to prevent infinite recursion for recursive rules. // Use TYPE_ANY because it is the identity of the bitwise 'or' operator, ensuring that a rule // like 'x = x | String' will return `TYPE_STRING`. memo[key] = pexprs.TYPE_ANY; memo[key] = inlinedBody.getExprType(grammar, memo); } return memo[key]; }; },{"./common":48,"./errors":49,"./pexprs":67}],60:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- /* Called at grammar creation time to rewrite a rule body, replacing each reference to a formal parameter with a `Param` node. Returns a PExpr -- either a new one, or the original one if it was modified in place. */ pexprs.PExpr.prototype.introduceParams = common.abstract; pexprs.any.introduceParams = pexprs.end.introduceParams = pexprs.Prim.prototype.introduceParams = pexprs.Range.prototype.introduceParams = pexprs.Param.prototype.introduceParams = pexprs.TypeCheck.prototype.introduceParams = pexprs.UnicodeChar.prototype.introduceParams = function(formals) { return this; }; pexprs.Alt.prototype.introduceParams = function(formals) { this.terms.forEach(function(term, idx, terms) { terms[idx] = term.introduceParams(formals); }); return this; }; pexprs.Seq.prototype.introduceParams = function(formals) { this.factors.forEach(function(factor, idx, factors) { factors[idx] = factor.introduceParams(formals); }); return this; }; pexprs.Iter.prototype.introduceParams = pexprs.Not.prototype.introduceParams = pexprs.Lookahead.prototype.introduceParams = pexprs.Lex.prototype.introduceParams = pexprs.Value.prototype.introduceParams = pexprs.Arr.prototype.introduceParams = function(formals) { this.expr = this.expr.introduceParams(formals); return this; }; pexprs.Obj.prototype.introduceParams = function(formals) { this.properties.forEach(function(property, idx) { property.pattern = property.pattern.introduceParams(formals); }); return this; }; pexprs.Apply.prototype.introduceParams = function(formals) { var index = formals.indexOf(this.ruleName); if (index >= 0) { if (this.args.length > 0) { // TODO: Should this be supported? See issue #64. throw new Error('Parameterized rules cannot be passed as arguments to another rule.'); } return new pexprs.Param(index); } else { this.args.forEach(function(arg, idx, args) { args[idx] = arg.introduceParams(formals); }); return this; } }; },{"./common":48,"./pexprs":67}],61:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- // Returns `true` if this parsing expression may accept without consuming any input. pexprs.PExpr.prototype.isNullable = function(grammar) { return this._isNullable(grammar, Object.create(null)); }; pexprs.PExpr.prototype._isNullable = common.abstract; pexprs.any._isNullable = pexprs.Range.prototype._isNullable = pexprs.Param.prototype._isNullable = pexprs.Plus.prototype._isNullable = pexprs.Value.prototype._isNullable = pexprs.Arr.prototype._isNullable = pexprs.Obj.prototype._isNullable = pexprs.TypeCheck.prototype._isNullable = pexprs.UnicodeChar.prototype._isNullable = function(grammar, memo) { return false; }; pexprs.end._isNullable = function(grammar, memo) { return true; }; pexprs.Prim.prototype._isNullable = function(grammar, memo) { if (typeof this.obj === 'string') { // This is an over-simplification: it's only correct if the input is a string. If it's an array // or an object, then the empty string parsing expression is not nullable. return this.obj === ''; } else { return false; } }; pexprs.Alt.prototype._isNullable = function(grammar, memo) { return this.terms.length === 0 || this.terms.some(function(term) { return term._isNullable(grammar, memo); }); }; pexprs.Seq.prototype._isNullable = function(grammar, memo) { return this.factors.every(function(factor) { return factor._isNullable(grammar, memo); }); }; pexprs.Star.prototype._isNullable = pexprs.Opt.prototype._isNullable = pexprs.Not.prototype._isNullable = pexprs.Lookahead.prototype._isNullable = function(grammar, memo) { return true; }; pexprs.Lex.prototype._isNullable = function(grammar, memo) { return this.expr._isNullable(grammar, memo); }; pexprs.Apply.prototype._isNullable = function(grammar, memo) { var key = this.toMemoKey(); if (!Object.prototype.hasOwnProperty.call(memo, key)) { var body = grammar.ruleBodies[this.ruleName]; var inlined = body.substituteParams(this.args); memo[key] = false; // Prevent infinite recursion for recursive rules. memo[key] = inlined._isNullable(grammar, memo); } return memo[key]; }; },{"./common":48,"./pexprs":67}],62:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- function escapeString(str) { var output = JSON.stringify(str); output = output.replace(/[\u2028\u2029]/g, function(char, pos, str) { var hex = char.codePointAt(0).toString(16); return '\\u' + '0000'.slice(hex.length) + hex; }); return output; } function getIntervalInfo(expr, grammarInterval) { if (expr.interval && grammarInterval) { var adjusted = expr.interval.relativeTo(grammarInterval); var start = adjusted.startIdx; var end = adjusted.endIdx; return '.withInterval(decl.sourceInterval(' + start + ', ' + end + '))'; } return ''; } // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- pexprs.PExpr.prototype.outputRecipe = common.abstract; pexprs.any.outputRecipe = function(sb, formals, grammarInterval) { throw new Error('should never output a recipe for `any` expression'); }; pexprs.end.outputRecipe = function(sb, formals, grammarInterval) { throw new Error('should never output a recipe for `end` expression'); }; pexprs.Prim.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.prim('); sb.append(typeof this.obj === 'string' ? escapeString(this.obj) : '' + this.obj); sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Range.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.range('); sb.append(JSON.stringify(this.from)); sb.append(', '); sb.append(JSON.stringify(this.to)); sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Param.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.param(' + this.index + ')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Alt.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.alt('); for (var idx = 0; idx < this.terms.length; idx++) { if (idx > 0) { sb.append(', '); } this.terms[idx].outputRecipe(sb, formals, grammarInterval); } sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Extend.prototype.outputRecipe = function(sb, formals, grammarInterval) { var extension = this.terms[0]; // [extension, orginal] extension.outputRecipe(sb, formals, grammarInterval); }; pexprs.Seq.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.seq('); for (var idx = 0; idx < this.factors.length; idx++) { if (idx > 0) { sb.append(', '); } this.factors[idx].outputRecipe(sb, formals, grammarInterval); } sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Star.prototype.outputRecipe = pexprs.Plus.prototype.outputRecipe = pexprs.Opt.prototype.outputRecipe = pexprs.Not.prototype.outputRecipe = pexprs.Lex.prototype.outputRecipe = pexprs.Arr.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.' + this.constructor.name.toLowerCase() + '('); this.expr.outputRecipe(sb, formals, grammarInterval); sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Lookahead.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.la('); this.expr.outputRecipe(sb, formals, grammarInterval); sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Value.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.val('); this.expr.outputRecipe(sb, formals, grammarInterval); sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Obj.prototype.outputRecipe = function(sb, formals, grammarInterval) { function outputPropertyRecipe(prop) { sb.append('{name: '); sb.append(JSON.stringify(prop.name)); sb.append(', pattern: '); prop.pattern.outputRecipe(sb, formals, grammarInterval); sb.append('}'); } sb.append('this.obj(['); for (var idx = 0; idx < this.properties.length; idx++) { if (idx > 0) { sb.append(', '); } outputPropertyRecipe(this.properties[idx]); } sb.append('], '); sb.append(!!this.isLenient); sb.append(')' + getIntervalInfo(this, grammarInterval)); }; pexprs.Apply.prototype.outputRecipe = function(sb, formals, grammarInterval) { sb.append('this.app('); sb.append(JSON.stringify(this.ruleName)); if (this.ruleName.indexOf('_') >= 0 && formals.length > 0) { var apps = formals. map(function(_, idx) { return 'this.param(' + idx + ')'; }); sb.append(', [' + apps.join(', ') + ']'); } else if (this.args.length > 0) { sb.append(', ['); this.args.forEach(function(arg, idx) { if (idx > 0) { sb.append(', '); } arg.outputRecipe(sb, formals, grammarInterval); }); sb.append(']'); } sb.append(')' + getIntervalInfo(this, grammarInterval)); }; },{"./common":48,"./pexprs":67}],63:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- /* Returns a PExpr that results from recursively replacing every formal parameter (i.e., instance of `Param`) inside this PExpr with its actual value from `actuals` (an Array). The receiver must not be modified; a new PExpr must be returned if any replacement is necessary. */ pexprs.PExpr.prototype.substituteParams = common.abstract; // function (actuals) { ... } pexprs.any.substituteParams = pexprs.end.substituteParams = pexprs.Prim.prototype.substituteParams = pexprs.Range.prototype.substituteParams = pexprs.Prim.prototype.substituteParams = pexprs.TypeCheck.prototype.substituteParams = pexprs.UnicodeChar.prototype.substituteParams = function(actuals) { return this; }; pexprs.Param.prototype.substituteParams = function(actuals) { return actuals[this.index]; }; pexprs.Alt.prototype.substituteParams = function(actuals) { return new pexprs.Alt( this.terms.map(function(term) { return term.substituteParams(actuals); })); }; pexprs.Seq.prototype.substituteParams = function(actuals) { return new pexprs.Seq( this.factors.map(function(factor) { return factor.substituteParams(actuals); })); }; pexprs.Iter.prototype.substituteParams = pexprs.Not.prototype.substituteParams = pexprs.Lookahead.prototype.substituteParams = pexprs.Lex.prototype.substituteParams = pexprs.Value.prototype.substituteParams = pexprs.Arr.prototype.substituteParams = function(actuals) { return new this.constructor(this.expr.substituteParams(actuals)); }; pexprs.Obj.prototype.substituteParams = function(actuals) { var properties = this.properties.map(function(property) { return { name: property.name, pattern: property.pattern.substituteParams(actuals) }; }); return new pexprs.Obj(properties, this.isLenient); }; pexprs.Apply.prototype.substituteParams = function(actuals) { if (this.args.length === 0) { // Avoid making a copy of this application, as an optimization return this; } else { var args = this.args.map(function(arg) { return arg.substituteParams(actuals); }); return new pexprs.Apply(this.ruleName, args); } }; },{"./common":48,"./pexprs":67}],64:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- // Returns a string representing the PExpr, for use as a UI label, etc. pexprs.PExpr.prototype.toDisplayString = common.abstract; pexprs.Alt.prototype.toDisplayString = pexprs.Seq.prototype.toDisplayString = pexprs.Iter.prototype.toDisplayString = pexprs.Not.prototype.toDisplayString = pexprs.Lookahead.prototype.toDisplayString = pexprs.Lex.prototype.toDisplayString = pexprs.Value.prototype.toDisplayString = pexprs.Arr.prototype.toDisplayString = pexprs.Obj.prototype.toDisplayString = function() { if (this.interval) { return this.interval.trimmed().contents; } return '[' + this.constructor.name + ']'; }; pexprs.any.toDisplayString = function() { return 'any'; }; pexprs.end.toDisplayString = function() { return 'end'; }; pexprs.Prim.prototype.toDisplayString = function() { return JSON.stringify(this.obj); }; pexprs.Range.prototype.toDisplayString = function() { return JSON.stringify(this.from) + '..' + JSON.stringify(this.to); }; pexprs.Param.prototype.toDisplayString = function() { return '#' + this.index; }; pexprs.Apply.prototype.toDisplayString = function() { return this.toString(); }; pexprs.UnicodeChar.prototype.toDisplayString = function() { return 'Unicode {' + this.category + '} character'; }; pexprs.TypeCheck.prototype.toDisplayString = function() { return 'TypeCheck(' + JSON.stringify(this.type) + ')'; }; },{"./common":48,"./pexprs":67}],65:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var Failure = require('./Failure'); var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- pexprs.PExpr.prototype.toFailure = common.abstract; pexprs.any.toFailure = function(grammar) { return new Failure('any object', 'description'); }; pexprs.end.toFailure = function(grammar) { return new Failure('end of input', 'description'); }; pexprs.Prim.prototype.toFailure = function(grammar) { return typeof this.obj === 'string' ? new Failure(this.obj, 'string') : new Failure(JSON.stringify(this.obj), 'code'); }; pexprs.Range.prototype.toFailure = function(grammar) { // TODO: come up with something better return new Failure(JSON.stringify(this.from) + '..' + JSON.stringify(this.to), 'code'); }; pexprs.Not.prototype.toFailure = function(grammar) { var description = this.expr === pexprs.any ? 'nothing' : 'not ' + this.expr.toFailure(grammar); return new Failure(description, 'description'); }; // TODO: think about Arr, Str, and Obj pexprs.Apply.prototype.toFailure = function(grammar) { var description = grammar.ruleDescriptions[this.ruleName]; if (!description) { var article = (/^[aeiouAEIOU]/.test(this.ruleName) ? 'an' : 'a'); description = article + ' ' + this.ruleName; } return new Failure(description, 'description'); }; pexprs.UnicodeChar.prototype.toFailure = function(grammar) { return new Failure(this.toDisplayString(), 'description'); }; pexprs.TypeCheck.prototype.toFailure = function(grammar) { return new Failure('a value of type ' + JSON.stringify(this.type), 'description'); }; },{"./Failure":37,"./common":48,"./pexprs":67}],66:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); var pexprs = require('./pexprs'); // -------------------------------------------------------------------- // Operations // -------------------------------------------------------------------- /* e1.toString() === e2.toString() ==> e1 and e2 are semantically equivalent. Note that this is not an iff (<==>): e.g., (~"b" "a").toString() !== ("a").toString(), even though ~"b" "a" and "a" are interchangeable in any grammar, both in terms of the languages they accept and their arities. */ pexprs.PExpr.prototype.toString = common.abstract; pexprs.any.toString = function() { return 'any'; }; pexprs.end.toString = function() { return 'end'; }; pexprs.Prim.prototype.toString = function() { return JSON.stringify(this.obj); }; pexprs.Range.prototype.toString = function() { return JSON.stringify(this.from) + '..' + JSON.stringify(this.to); }; pexprs.Param.prototype.toString = function() { return '$' + this.index; }; pexprs.Lex.prototype.toString = function() { return '#(' + this.expr.toString() + ')'; }; pexprs.Value.prototype.toString = function() { return '$(' + this.expr.toString() + ')'; }; pexprs.Alt.prototype.toString = function() { return this.terms.length === 1 ? this.terms[0].toString() : '(' + this.terms.map(function(term) { return term.toString(); }).join(' | ') + ')'; }; pexprs.Seq.prototype.toString = function() { return this.factors.length === 1 ? this.factors[0].toString() : '(' + this.factors.map(function(factor) { return factor.toString(); }).join(' ') + ')'; }; pexprs.Iter.prototype.toString = function() { return this.expr + this.operator; }; pexprs.Not.prototype.toString = function() { return '~' + this.expr; }; pexprs.Lookahead.prototype.toString = function() { return '&' + this.expr; }; pexprs.Arr.prototype.toString = function() { return '[' + this.expr.toString() + ']'; }; pexprs.Obj.prototype.toString = function() { var parts = ['{']; var first = true; function emit(part) { if (first) { first = false; } else { parts.push(', '); } parts.push(part); } this.properties.forEach(function(property) { emit(JSON.stringify(property.name) + ': ' + property.pattern.toString()); }); if (this.isLenient) { emit('...'); } parts.push('}'); return parts.join(''); }; pexprs.Apply.prototype.toString = function() { if (this.args.length > 0) { var ps = this.args.map(function(arg) { return arg.toString(); }); return this.ruleName + '<' + ps.join(',') + '>'; } else { return this.ruleName; } }; pexprs.UnicodeChar.prototype.toString = function() { return '\\p{' + this.category + '}'; }; pexprs.TypeCheck.prototype.toString = function() { return 'TypeCheck(' + JSON.stringify(this.type) + ')'; }; },{"./common":48,"./pexprs":67}],67:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var InputStream = require('./InputStream'); var UnicodeCategories = require('../third_party/UnicodeCategories'); var common = require('./common'); var errors = require('./errors'); var inherits = require('inherits'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- // General stuff // Constants representing the type of a PExpr. See pexprs-getExprType.js for // more information. var TYPE_ANY = 0; var TYPE_STRING = 1; var TYPE_VALUE = 2; function PExpr() { throw new Error("PExpr cannot be instantiated -- it's abstract"); } // Set the `interval` property to the interval containing the source for this expression. PExpr.prototype.withInterval = function(interval) { if (interval) { this.interval = interval.trimmed(); } return this; }; // Allocate the appropriate input stream for this expression and the given values. PExpr.prototype.newInputStreamFor = function(values, grammar) { var exprType = this.getExprType(grammar); if (values.length === 1 && typeof values[0] === 'string' && exprType !== TYPE_VALUE) { return InputStream.newFor(values[0]); } else { return InputStream.newFor(values); } }; // Any var any = Object.create(PExpr.prototype); // End var end = Object.create(PExpr.prototype); // Primitives function Prim(obj) { this.obj = obj; } inherits(Prim, PExpr); // Ranges function Range(from, to) { this.from = from; this.to = to; } inherits(Range, PExpr); // Parameters function Param(index) { this.index = index; } inherits(Param, PExpr); // Alternation function Alt(terms) { this.terms = terms; } inherits(Alt, PExpr); // Extend is an implementation detail of rule extension function Extend(superGrammar, name, body) { this.superGrammar = superGrammar; this.name = name; this.body = body; var origBody = superGrammar.ruleBodies[name]; this.terms = [body, origBody]; } inherits(Extend, Alt); // Sequences function Seq(factors) { this.factors = factors; } inherits(Seq, PExpr); // Iterators and optionals function Iter(expr) { this.expr = expr; } inherits(Iter, PExpr); function Star(expr) { this.expr = expr; } inherits(Star, Iter); function Plus(expr) { this.expr = expr; } inherits(Plus, Iter); function Opt(expr) { this.expr = expr; } inherits(Opt, Iter); Star.prototype.operator = '*'; Plus.prototype.operator = '+'; Opt.prototype.operator = '?'; Star.prototype.minNumMatches = 0; Plus.prototype.minNumMatches = 1; Opt.prototype.minNumMatches = 0; Star.prototype.maxNumMatches = Number.POSITIVE_INFINITY; Plus.prototype.maxNumMatches = Number.POSITIVE_INFINITY; Opt.prototype.maxNumMatches = 1; // Predicates function Not(expr) { this.expr = expr; } inherits(Not, PExpr); function Lookahead(expr) { this.expr = expr; } inherits(Lookahead, PExpr); // "Lexification" function Lex(expr) { this.expr = expr; } inherits(Lex, PExpr); // "Value-ification" function Value(expr) { this.expr = expr; } inherits(Value, PExpr); // Array decomposition function Arr(expr) { this.expr = expr; } inherits(Arr, PExpr); // String decomposition function Str(expr) { this.expr = expr; } inherits(Str, PExpr); // Object decomposition function Obj(properties, isLenient) { var names = properties.map(function(property) { return property.name; }); var duplicates = common.getDuplicates(names); if (duplicates.length > 0) { throw errors.duplicatePropertyNames(duplicates); } else { this.properties = properties; this.isLenient = isLenient; } } inherits(Obj, PExpr); // Rule application function Apply(ruleName, optArgs) { this.ruleName = ruleName; this.args = optArgs || []; } inherits(Apply, PExpr); Apply.prototype.isSyntactic = function() { return common.isSyntactic(this.ruleName); }; // This method just caches the result of `this.toString()` in a non-enumerable property. Apply.prototype.toMemoKey = function() { if (!this._memoKey) { Object.defineProperty(this, '_memoKey', {value: this.toString()}); } return this._memoKey; }; // Unicode character function UnicodeChar(category) { this.category = category; this.pattern = UnicodeCategories[category]; } inherits(UnicodeChar, PExpr); // Matches a value of a particular type (using `typeof`). function TypeCheck(t) { this.type = t; } inherits(TypeCheck, PExpr); // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- exports.TYPE_ANY = TYPE_ANY; exports.TYPE_STRING = TYPE_STRING; exports.TYPE_VALUE = TYPE_VALUE; exports.TYPE_INCONSISTENT = TYPE_STRING | TYPE_VALUE; exports.PExpr = PExpr; exports.any = any; exports.end = end; exports.Prim = Prim; exports.Range = Range; exports.Param = Param; exports.Alt = Alt; exports.Extend = Extend; exports.Seq = Seq; exports.Iter = Iter; exports.Star = Star; exports.Plus = Plus; exports.Opt = Opt; exports.Not = Not; exports.Lookahead = Lookahead; exports.Lex = Lex; exports.Value = Value; exports.Arr = Arr; exports.Str = Str; exports.Obj = Obj; exports.Apply = Apply; exports.UnicodeChar = UnicodeChar; exports.TypeCheck = TypeCheck; // -------------------------------------------------------------------- // Extensions // -------------------------------------------------------------------- require('./pexprs-assertAllApplicationsAreValid'); require('./pexprs-assertChoicesHaveUniformArity'); require('./pexprs-assertIteratedExprsAreNotNullable'); require('./pexprs-assertValuesAndStringsAreNotMixed'); require('./pexprs-check'); require('./pexprs-eval'); require('./pexprs-getArity'); require('./pexprs-getExprType'); require('./pexprs-outputRecipe'); require('./pexprs-introduceParams'); require('./pexprs-isNullable'); require('./pexprs-substituteParams'); require('./pexprs-toDisplayString'); require('./pexprs-toFailure'); require('./pexprs-toString'); },{"../third_party/UnicodeCategories":69,"./InputStream":40,"./common":48,"./errors":49,"./pexprs-assertAllApplicationsAreValid":52,"./pexprs-assertChoicesHaveUniformArity":53,"./pexprs-assertIteratedExprsAreNotNullable":54,"./pexprs-assertValuesAndStringsAreNotMixed":55,"./pexprs-check":56,"./pexprs-eval":57,"./pexprs-getArity":58,"./pexprs-getExprType":59,"./pexprs-introduceParams":60,"./pexprs-isNullable":61,"./pexprs-outputRecipe":62,"./pexprs-substituteParams":63,"./pexprs-toDisplayString":64,"./pexprs-toFailure":65,"./pexprs-toString":66,"inherits":33}],68:[function(require,module,exports){ 'use strict'; // -------------------------------------------------------------------- // Imports // -------------------------------------------------------------------- var common = require('./common'); // -------------------------------------------------------------------- // Private stuff // -------------------------------------------------------------------- // Given an array of numbers `arr`, return an array of the numbers as strings, // right-justified and padded to the same length. function padNumbersToEqualLength(arr) { var maxLen = 0; var strings = arr.map(function(n) { var str = n.toString(); maxLen = Math.max(maxLen, str.length); return str; }); return strings.map(function(s) { return common.padLeft(s, maxLen); }); } // Produce a new string that would be the result of copying the contents // of the string `src` onto `dest` at offset `offest`. function strcpy(dest, src, offset) { var origDestLen = dest.length; var start = dest.slice(0, offset); var end = dest.slice(offset + src.length); return (start + src + end).substr(0, origDestLen); } // -------------------------------------------------------------------- // Exports // -------------------------------------------------------------------- // Return an object with the line and column information for the given // offset in `str`. exports.getLineAndColumn = function(str, offset) { var lineNum = 1; var colNum = 1; var currOffset = 0; var lineStartOffset = 0; var nextLine = null; var prevLine = null; var prevLineStartOffset = -1; while (currOffset < offset) { var c = str.charAt(currOffset++); if (c === '\n') { lineNum++; colNum = 1; prevLineStartOffset = lineStartOffset; lineStartOffset = currOffset; } else if (c !== '\r') { colNum++; } } // Find the end of the target line. var lineEndOffset = str.indexOf('\n', lineStartOffset); if (lineEndOffset === -1) { lineEndOffset = str.length; } else { // Get the next line. var nextLineEndOffset = str.indexOf('\n', lineEndOffset + 1); nextLine = nextLineEndOffset === -1 ? str.slice(lineEndOffset) : str.slice(lineEndOffset, nextLineEndOffset); // Strip leading and trailing EOL char(s). nextLine = nextLine.replace(/^\r?\n/, '').replace(/\r$/, ''); } // Get the previous line. if (prevLineStartOffset >= 0) { prevLine = str.slice(prevLineStartOffset, lineStartOffset) .replace(/\r?\n$/, ''); // Strip trailing EOL char(s). } // Get the target line, stripping a trailing carriage return if necessary. var line = str.slice(lineStartOffset, lineEndOffset).replace(/\r$/, ''); return { lineNum: lineNum, colNum: colNum, line: line, prevLine: prevLine, nextLine: nextLine }; }; // Return a nicely-formatted string describing the line and column for the // given offset in `str`. exports.getLineAndColumnMessage = function(str, offset /* ...ranges */) { var repeatStr = common.repeatStr; var lineAndCol = exports.getLineAndColumn(str, offset); var sb = new common.StringBuffer(); sb.append('Line ' + lineAndCol.lineNum + ', col ' + lineAndCol.colNum + ':\n'); // An array of the previous, current, and next line numbers as strings of equal length. var lineNumbers = padNumbersToEqualLength([ lineAndCol.prevLine == null ? 0 : lineAndCol.lineNum - 1, lineAndCol.lineNum, lineAndCol.nextLine == null ? 0 : lineAndCol.lineNum + 1 ]); // Helper for appending formatting input lines to the buffer. function appendLine(num, content, prefix) { sb.append(prefix + lineNumbers[num] + ' | ' + content + '\n'); } // Include the previous line for context if possible. if (lineAndCol.prevLine != null) { appendLine(0, lineAndCol.prevLine, ' '); } // Line that the error occurred on. appendLine(1, lineAndCol.line, '> '); // Build up the line that points to the offset and possible indicates one or more ranges. // Start with a blank line, and indicate each range by overlaying a string of `~` chars. var lineLen = lineAndCol.line.length; var indicationLine = repeatStr(' ', lineLen + 1); var ranges = Array.prototype.slice.call(arguments, 2); for (var i = 0; i < ranges.length; ++i) { var startIdx = ranges[i][0]; var endIdx = ranges[i][1]; common.assert(startIdx >= 0 && startIdx <= endIdx, 'range start must be >= 0 and <= end'); var lineStartOffset = offset - lineAndCol.colNum + 1; startIdx = Math.max(0, startIdx - lineStartOffset); endIdx = Math.min(endIdx - lineStartOffset, lineLen); indicationLine = strcpy(indicationLine, repeatStr('~', endIdx - startIdx), startIdx); } var gutterWidth = 2 + lineNumbers[1].length + 3; sb.append(repeatStr(' ', gutterWidth)); indicationLine = strcpy(indicationLine, '^', lineAndCol.colNum - 1); sb.append(indicationLine.replace(/ +$/, '') + '\n'); // Include the next line for context if possible. if (lineAndCol.nextLine != null) { appendLine(2, lineAndCol.nextLine, ' '); } return sb.contents(); }; },{"./common":48}],69:[function(require,module,exports){ // Based on https://github.com/tvcutsem/es-lab/blob/master/src/parser/unicode.js. // These are just categories that are used in ES5. // The full list of Unicode categories is here: http://www.fileformat.info/info/unicode/category/index.htm. module.exports = { // Letters Lu: /[\u0041-\u005A]|[\u00C0-\u00D6]|[\u00D8-\u00DE]|[\u0100-\u0100]|[\u0102-\u0102]|[\u0104-\u0104]|[\u0106-\u0106]|[\u0108-\u0108]|[\u010A-\u010A]|[\u010C-\u010C]|[\u010E-\u010E]|[\u0110-\u0110]|[\u0112-\u0112]|[\u0114-\u0114]|[\u0116-\u0116]|[\u0118-\u0118]|[\u011A-\u011A]|[\u011C-\u011C]|[\u011E-\u011E]|[\u0120-\u0120]|[\u0122-\u0122]|[\u0124-\u0124]|[\u0126-\u0126]|[\u0128-\u0128]|[\u012A-\u012A]|[\u012C-\u012C]|[\u012E-\u012E]|[\u0130-\u0130]|[\u0132-\u0132]|[\u0134-\u0134]|[\u0136-\u0136]|[\u0139-\u0139]|[\u013B-\u013B]|[\u013D-\u013D]|[\u013F-\u013F]|[\u0141-\u0141]|[\u0143-\u0143]|[\u0145-\u0145]|[\u0147-\u0147]|[\u014A-\u014A]|[\u014C-\u014C]|[\u014E-\u014E]|[\u0150-\u0150]|[\u0152-\u0152]|[\u0154-\u0154]|[\u0156-\u0156]|[\u0158-\u0158]|[\u015A-\u015A]|[\u015C-\u015C]|[\u015E-\u015E]|[\u0160-\u0160]|[\u0162-\u0162]|[\u0164-\u0164]|[\u0166-\u0166]|[\u0168-\u0168]|[\u016A-\u016A]|[\u016C-\u016C]|[\u016E-\u016E]|[\u0170-\u0170]|[\u0172-\u0172]|[\u0174-\u0174]|[\u0176-\u0176]|[\u0178-\u0179]|[\u017B-\u017B]|[\u017D-\u017D]|[\u0181-\u0182]|[\u0184-\u0184]|[\u0186-\u0187]|[\u0189-\u018B]|[\u018E-\u0191]|[\u0193-\u0194]|[\u0196-\u0198]|[\u019C-\u019D]|[\u019F-\u01A0]|[\u01A2-\u01A2]|[\u01A4-\u01A4]|[\u01A6-\u01A7]|[\u01A9-\u01A9]|[\u01AC-\u01AC]|[\u01AE-\u01AF]|[\u01B1-\u01B3]|[\u01B5-\u01B5]|[\u01B7-\u01B8]|[\u01BC-\u01BC]|[\u01C4-\u01C4]|[\u01C7-\u01C7]|[\u01CA-\u01CA]|[\u01CD-\u01CD]|[\u01CF-\u01CF]|[\u01D1-\u01D1]|[\u01D3-\u01D3]|[\u01D5-\u01D5]|[\u01D7-\u01D7]|[\u01D9-\u01D9]|[\u01DB-\u01DB]|[\u01DE-\u01DE]|[\u01E0-\u01E0]|[\u01E2-\u01E2]|[\u01E4-\u01E4]|[\u01E6-\u01E6]|[\u01E8-\u01E8]|[\u01EA-\u01EA]|[\u01EC-\u01EC]|[\u01EE-\u01EE]|[\u01F1-\u01F1]|[\u01F4-\u01F4]|[\u01FA-\u01FA]|[\u01FC-\u01FC]|[\u01FE-\u01FE]|[\u0200-\u0200]|[\u0202-\u0202]|[\u0204-\u0204]|[\u0206-\u0206]|[\u0208-\u0208]|[\u020A-\u020A]|[\u020C-\u020C]|[\u020E-\u020E]|[\u0210-\u0210]|[\u0212-\u0212]|[\u0214-\u0214]|[\u0216-\u0216]|[\u0386-\u0386]|[\u0388-\u038A]|[\u038C-\u038C]|[\u038E-\u038F]|[\u0391-\u03A1]|[\u03A3-\u03AB]|[\u03D2-\u03D4]|[\u03DA-\u03DA]|[\u03DC-\u03DC]|[\u03DE-\u03DE]|[\u03E0-\u03E0]|[\u03E2-\u03E2]|[\u03E4-\u03E4]|[\u03E6-\u03E6]|[\u03E8-\u03E8]|[\u03EA-\u03EA]|[\u03EC-\u03EC]|[\u03EE-\u03EE]|[\u0401-\u040C]|[\u040E-\u042F]|[\u0460-\u0460]|[\u0462-\u0462]|[\u0464-\u0464]|[\u0466-\u0466]|[\u0468-\u0468]|[\u046A-\u046A]|[\u046C-\u046C]|[\u046E-\u046E]|[\u0470-\u0470]|[\u0472-\u0472]|[\u0474-\u0474]|[\u0476-\u0476]|[\u0478-\u0478]|[\u047A-\u047A]|[\u047C-\u047C]|[\u047E-\u047E]|[\u0480-\u0480]|[\u0490-\u0490]|[\u0492-\u0492]|[\u0494-\u0494]|[\u0496-\u0496]|[\u0498-\u0498]|[\u049A-\u049A]|[\u049C-\u049C]|[\u049E-\u049E]|[\u04A0-\u04A0]|[\u04A2-\u04A2]|[\u04A4-\u04A4]|[\u04A6-\u04A6]|[\u04A8-\u04A8]|[\u04AA-\u04AA]|[\u04AC-\u04AC]|[\u04AE-\u04AE]|[\u04B0-\u04B0]|[\u04B2-\u04B2]|[\u04B4-\u04B4]|[\u04B6-\u04B6]|[\u04B8-\u04B8]|[\u04BA-\u04BA]|[\u04BC-\u04BC]|[\u04BE-\u04BE]|[\u04C1-\u04C1]|[\u04C3-\u04C3]|[\u04C7-\u04C7]|[\u04CB-\u04CB]|[\u04D0-\u04D0]|[\u04D2-\u04D2]|[\u04D4-\u04D4]|[\u04D6-\u04D6]|[\u04D8-\u04D8]|[\u04DA-\u04DA]|[\u04DC-\u04DC]|[\u04DE-\u04DE]|[\u04E0-\u04E0]|[\u04E2-\u04E2]|[\u04E4-\u04E4]|[\u04E6-\u04E6]|[\u04E8-\u04E8]|[\u04EA-\u04EA]|[\u04EE-\u04EE]|[\u04F0-\u04F0]|[\u04F2-\u04F2]|[\u04F4-\u04F4]|[\u04F8-\u04F8]|[\u0531-\u0556]|[\u10A0-\u10C5]|[\u1E00-\u1E00]|[\u1E02-\u1E02]|[\u1E04-\u1E04]|[\u1E06-\u1E06]|[\u1E08-\u1E08]|[\u1E0A-\u1E0A]|[\u1E0C-\u1E0C]|[\u1E0E-\u1E0E]|[\u1E10-\u1E10]|[\u1E12-\u1E12]|[\u1E14-\u1E14]|[\u1E16-\u1E16]|[\u1E18-\u1E18]|[\u1E1A-\u1E1A]|[\u1E1C-\u1E1C]|[\u1E1E-\u1E1E]|[\u1E20-\u1E20]|[\u1E22-\u1E22]|[\u1E24-\u1E24]|[\u1E26-\u1E26]|[\u1E28-\u1E28]|[\u1E2A-\u1E2A]|[\u1E2C-\u1E2C]|[\u1E2E-\u1E2E]|[\u1E30-\u1E30]|[\u1E32-\u1E32]|[\u1E34-\u1E34]|[\u1E36-\u1E36]|[\u1E38-\u1E38]|[\u1E3A-\u1E3A]|[\u1E3C-\u1E3C]|[\u1E3E-\u1E3E]|[\u1E40-\u1E40]|[\u1E42-\u1E42]|[\u1E44-\u1E44]|[\u1E46-\u1E46]|[\u1E48-\u1E48]|[\u1E4A-\u1E4A]|[\u1E4C-\u1E4C]|[\u1E4E-\u1E4E]|[\u1E50-\u1E50]|[\u1E52-\u1E52]|[\u1E54-\u1E54]|[\u1E56-\u1E56]|[\u1E58-\u1E58]|[\u1E5A-\u1E5A]|[\u1E5C-\u1E5C]|[\u1E5E-\u1E5E]|[\u1E60-\u1E60]|[\u1E62-\u1E62]|[\u1E64-\u1E64]|[\u1E66-\u1E66]|[\u1E68-\u1E68]|[\u1E6A-\u1E6A]|[\u1E6C-\u1E6C]|[\u1E6E-\u1E6E]|[\u1E70-\u1E70]|[\u1E72-\u1E72]|[\u1E74-\u1E74]|[\u1E76-\u1E76]|[\u1E78-\u1E78]|[\u1E7A-\u1E7A]|[\u1E7C-\u1E7C]|[\u1E7E-\u1E7E]|[\u1E80-\u1E80]|[\u1E82-\u1E82]|[\u1E84-\u1E84]|[\u1E86-\u1E86]|[\u1E88-\u1E88]|[\u1E8A-\u1E8A]|[\u1E8C-\u1E8C]|[\u1E8E-\u1E8E]|[\u1E90-\u1E90]|[\u1E92-\u1E92]|[\u1E94-\u1E94]|[\u1EA0-\u1EA0]|[\u1EA2-\u1EA2]|[\u1EA4-\u1EA4]|[\u1EA6-\u1EA6]|[\u1EA8-\u1EA8]|[\u1EAA-\u1EAA]|[\u1EAC-\u1EAC]|[\u1EAE-\u1EAE]|[\u1EB0-\u1EB0]|[\u1EB2-\u1EB2]|[\u1EB4-\u1EB4]|[\u1EB6-\u1EB6]|[\u1EB8-\u1EB8]|[\u1EBA-\u1EBA]|[\u1EBC-\u1EBC]|[\u1EBE-\u1EBE]|[\u1EC0-\u1EC0]|[\u1EC2-\u1EC2]|[\u1EC4-\u1EC4]|[\u1EC6-\u1EC6]|[\u1EC8-\u1EC8]|[\u1ECA-\u1ECA]|[\u1ECC-\u1ECC]|[\u1ECE-\u1ECE]|[\u1ED0-\u1ED0]|[\u1ED2-\u1ED2]|[\u1ED4-\u1ED4]|[\u1ED6-\u1ED6]|[\u1ED8-\u1ED8]|[\u1EDA-\u1EDA]|[\u1EDC-\u1EDC]|[\u1EDE-\u1EDE]|[\u1EE0-\u1EE0]|[\u1EE2-\u1EE2]|[\u1EE4-\u1EE4]|[\u1EE6-\u1EE6]|[\u1EE8-\u1EE8]|[\u1EEA-\u1EEA]|[\u1EEC-\u1EEC]|[\u1EEE-\u1EEE]|[\u1EF0-\u1EF0]|[\u1EF2-\u1EF2]|[\u1EF4-\u1EF4]|[\u1EF6-\u1EF6]|[\u1EF8-\u1EF8]|[\u1F08-\u1F0F]|[\u1F18-\u1F1D]|[\u1F28-\u1F2F]|[\u1F38-\u1F3F]|[\u1F48-\u1F4D]|[\u1F59-\u1F59]|[\u1F5B-\u1F5B]|[\u1F5D-\u1F5D]|[\u1F5F-\u1F5F]|[\u1F68-\u1F6F]|[\u1F88-\u1F8F]|[\u1F98-\u1F9F]|[\u1FA8-\u1FAF]|[\u1FB8-\u1FBC]|[\u1FC8-\u1FCC]|[\u1FD8-\u1FDB]|[\u1FE8-\u1FEC]|[\u1FF8-\u1FFC]|[\u2102-\u2102]|[\u2107-\u2107]|[\u210B-\u210D]|[\u2110-\u2112]|[\u2115-\u2115]|[\u2119-\u211D]|[\u2124-\u2124]|[\u2126-\u2126]|[\u2128-\u2128]|[\u212A-\u212D]|[\u2130-\u2131]|[\u2133-\u2133]|[\uFF21-\uFF3A]/, Ll: /[\u0061-\u007A]|[\u00AA-\u00AA]|[\u00B5-\u00B5]|[\u00BA-\u00BA]|[\u00DF-\u00F6]|[\u00F8-\u00FF]|[\u0101-\u0101]|[\u0103-\u0103]|[\u0105-\u0105]|[\u0107-\u0107]|[\u0109-\u0109]|[\u010B-\u010B]|[\u010D-\u010D]|[\u010F-\u010F]|[\u0111-\u0111]|[\u0113-\u0113]|[\u0115-\u0115]|[\u0117-\u0117]|[\u0119-\u0119]|[\u011B-\u011B]|[\u011D-\u011D]|[\u011F-\u011F]|[\u0121-\u0121]|[\u0123-\u0123]|[\u0125-\u0125]|[\u0127-\u0127]|[\u0129-\u0129]|[\u012B-\u012B]|[\u012D-\u012D]|[\u012F-\u012F]|[\u0131-\u0131]|[\u0133-\u0133]|[\u0135-\u0135]|[\u0137-\u0138]|[\u013A-\u013A]|[\u013C-\u013C]|[\u013E-\u013E]|[\u0140-\u0140]|[\u0142-\u0142]|[\u0144-\u0144]|[\u0146-\u0146]|[\u0148-\u0149]|[\u014B-\u014B]|[\u014D-\u014D]|[\u014F-\u014F]|[\u0151-\u0151]|[\u0153-\u0153]|[\u0155-\u0155]|[\u0157-\u0157]|[\u0159-\u0159]|[\u015B-\u015B]|[\u015D-\u015D]|[\u015F-\u015F]|[\u0161-\u0161]|[\u0163-\u0163]|[\u0165-\u0165]|[\u0167-\u0167]|[\u0169-\u0169]|[\u016B-\u016B]|[\u016D-\u016D]|[\u016F-\u016F]|[\u0171-\u0171]|[\u0173-\u0173]|[\u0175-\u0175]|[\u0177-\u0177]|[\u017A-\u017A]|[\u017C-\u017C]|[\u017E-\u0180]|[\u0183-\u0183]|[\u0185-\u0185]|[\u0188-\u0188]|[\u018C-\u018D]|[\u0192-\u0192]|[\u0195-\u0195]|[\u0199-\u019B]|[\u019E-\u019E]|[\u01A1-\u01A1]|[\u01A3-\u01A3]|[\u01A5-\u01A5]|[\u01A8-\u01A8]|[\u01AB-\u01AB]|[\u01AD-\u01AD]|[\u01B0-\u01B0]|[\u01B4-\u01B4]|[\u01B6-\u01B6]|[\u01B9-\u01BA]|[\u01BD-\u01BD]|[\u01C6-\u01C6]|[\u01C9-\u01C9]|[\u01CC-\u01CC]|[\u01CE-\u01CE]|[\u01D0-\u01D0]|[\u01D2-\u01D2]|[\u01D4-\u01D4]|[\u01D6-\u01D6]|[\u01D8-\u01D8]|[\u01DA-\u01DA]|[\u01DC-\u01DD]|[\u01DF-\u01DF]|[\u01E1-\u01E1]|[\u01E3-\u01E3]|[\u01E5-\u01E5]|[\u01E7-\u01E7]|[\u01E9-\u01E9]|[\u01EB-\u01EB]|[\u01ED-\u01ED]|[\u01EF-\u01F0]|[\u01F3-\u01F3]|[\u01F5-\u01F5]|[\u01FB-\u01FB]|[\u01FD-\u01FD]|[\u01FF-\u01FF]|[\u0201-\u0201]|[\u0203-\u0203]|[\u0205-\u0205]|[\u0207-\u0207]|[\u0209-\u0209]|[\u020B-\u020B]|[\u020D-\u020D]|[\u020F-\u020F]|[\u0211-\u0211]|[\u0213-\u0213]|[\u0215-\u0215]|[\u0217-\u0217]|[\u0250-\u02A8]|[\u0390-\u0390]|[\u03AC-\u03CE]|[\u03D0-\u03D1]|[\u03D5-\u03D6]|[\u03E3-\u03E3]|[\u03E5-\u03E5]|[\u03E7-\u03E7]|[\u03E9-\u03E9]|[\u03EB-\u03EB]|[\u03ED-\u03ED]|[\u03EF-\u03F2]|[\u0430-\u044F]|[\u0451-\u045C]|[\u045E-\u045F]|[\u0461-\u0461]|[\u0463-\u0463]|[\u0465-\u0465]|[\u0467-\u0467]|[\u0469-\u0469]|[\u046B-\u046B]|[\u046D-\u046D]|[\u046F-\u046F]|[\u0471-\u0471]|[\u0473-\u0473]|[\u0475-\u0475]|[\u0477-\u0477]|[\u0479-\u0479]|[\u047B-\u047B]|[\u047D-\u047D]|[\u047F-\u047F]|[\u0481-\u0481]|[\u0491-\u0491]|[\u0493-\u0493]|[\u0495-\u0495]|[\u0497-\u0497]|[\u0499-\u0499]|[\u049B-\u049B]|[\u049D-\u049D]|[\u049F-\u049F]|[\u04A1-\u04A1]|[\u04A3-\u04A3]|[\u04A5-\u04A5]|[\u04A7-\u04A7]|[\u04A9-\u04A9]|[\u04AB-\u04AB]|[\u04AD-\u04AD]|[\u04AF-\u04AF]|[\u04B1-\u04B1]|[\u04B3-\u04B3]|[\u04B5-\u04B5]|[\u04B7-\u04B7]|[\u04B9-\u04B9]|[\u04BB-\u04BB]|[\u04BD-\u04BD]|[\u04BF-\u04BF]|[\u04C2-\u04C2]|[\u04C4-\u04C4]|[\u04C8-\u04C8]|[\u04CC-\u04CC]|[\u04D1-\u04D1]|[\u04D3-\u04D3]|[\u04D5-\u04D5]|[\u04D7-\u04D7]|[\u04D9-\u04D9]|[\u04DB-\u04DB]|[\u04DD-\u04DD]|[\u04DF-\u04DF]|[\u04E1-\u04E1]|[\u04E3-\u04E3]|[\u04E5-\u04E5]|[\u04E7-\u04E7]|[\u04E9-\u04E9]|[\u04EB-\u04EB]|[\u04EF-\u04EF]|[\u04F1-\u04F1]|[\u04F3-\u04F3]|[\u04F5-\u04F5]|[\u04F9-\u04F9]|[\u0561-\u0587]|[\u10D0-\u10F6]|[\u1E01-\u1E01]|[\u1E03-\u1E03]|[\u1E05-\u1E05]|[\u1E07-\u1E07]|[\u1E09-\u1E09]|[\u1E0B-\u1E0B]|[\u1E0D-\u1E0D]|[\u1E0F-\u1E0F]|[\u1E11-\u1E11]|[\u1E13-\u1E13]|[\u1E15-\u1E15]|[\u1E17-\u1E17]|[\u1E19-\u1E19]|[\u1E1B-\u1E1B]|[\u1E1D-\u1E1D]|[\u1E1F-\u1E1F]|[\u1E21-\u1E21]|[\u1E23-\u1E23]|[\u1E25-\u1E25]|[\u1E27-\u1E27]|[\u1E29-\u1E29]|[\u1E2B-\u1E2B]|[\u1E2D-\u1E2D]|[\u1E2F-\u1E2F]|[\u1E31-\u1E31]|[\u1E33-\u1E33]|[\u1E35-\u1E35]|[\u1E37-\u1E37]|[\u1E39-\u1E39]|[\u1E3B-\u1E3B]|[\u1E3D-\u1E3D]|[\u1E3F-\u1E3F]|[\u1E41-\u1E41]|[\u1E43-\u1E43]|[\u1E45-\u1E45]|[\u1E47-\u1E47]|[\u1E49-\u1E49]|[\u1E4B-\u1E4B]|[\u1E4D-\u1E4D]|[\u1E4F-\u1E4F]|[\u1E51-\u1E51]|[\u1E53-\u1E53]|[\u1E55-\u1E55]|[\u1E57-\u1E57]|[\u1E59-\u1E59]|[\u1E5B-\u1E5B]|[\u1E5D-\u1E5D]|[\u1E5F-\u1E5F]|[\u1E61-\u1E61]|[\u1E63-\u1E63]|[\u1E65-\u1E65]|[\u1E67-\u1E67]|[\u1E69-\u1E69]|[\u1E6B-\u1E6B]|[\u1E6D-\u1E6D]|[\u1E6F-\u1E6F]|[\u1E71-\u1E71]|[\u1E73-\u1E73]|[\u1E75-\u1E75]|[\u1E77-\u1E77]|[\u1E79-\u1E79]|[\u1E7B-\u1E7B]|[\u1E7D-\u1E7D]|[\u1E7F-\u1E7F]|[\u1E81-\u1E81]|[\u1E83-\u1E83]|[\u1E85-\u1E85]|[\u1E87-\u1E87]|[\u1E89-\u1E89]|[\u1E8B-\u1E8B]|[\u1E8D-\u1E8D]|[\u1E8F-\u1E8F]|[\u1E91-\u1E91]|[\u1E93-\u1E93]|[\u1E95-\u1E9B]|[\u1EA1-\u1EA1]|[\u1EA3-\u1EA3]|[\u1EA5-\u1EA5]|[\u1EA7-\u1EA7]|[\u1EA9-\u1EA9]|[\u1EAB-\u1EAB]|[\u1EAD-\u1EAD]|[\u1EAF-\u1EAF]|[\u1EB1-\u1EB1]|[\u1EB3-\u1EB3]|[\u1EB5-\u1EB5]|[\u1EB7-\u1EB7]|[\u1EB9-\u1EB9]|[\u1EBB-\u1EBB]|[\u1EBD-\u1EBD]|[\u1EBF-\u1EBF]|[\u1EC1-\u1EC1]|[\u1EC3-\u1EC3]|[\u1EC5-\u1EC5]|[\u1EC7-\u1EC7]|[\u1EC9-\u1EC9]|[\u1ECB-\u1ECB]|[\u1ECD-\u1ECD]|[\u1ECF-\u1ECF]|[\u1ED1-\u1ED1]|[\u1ED3-\u1ED3]|[\u1ED5-\u1ED5]|[\u1ED7-\u1ED7]|[\u1ED9-\u1ED9]|[\u1EDB-\u1EDB]|[\u1EDD-\u1EDD]|[\u1EDF-\u1EDF]|[\u1EE1-\u1EE1]|[\u1EE3-\u1EE3]|[\u1EE5-\u1EE5]|[\u1EE7-\u1EE7]|[\u1EE9-\u1EE9]|[\u1EEB-\u1EEB]|[\u1EED-\u1EED]|[\u1EEF-\u1EEF]|[\u1EF1-\u1EF1]|[\u1EF3-\u1EF3]|[\u1EF5-\u1EF5]|[\u1EF7-\u1EF7]|[\u1EF9-\u1EF9]|[\u1F00-\u1F07]|[\u1F10-\u1F15]|[\u1F20-\u1F27]|[\u1F30-\u1F37]|[\u1F40-\u1F45]|[\u1F50-\u1F57]|[\u1F60-\u1F67]|[\u1F70-\u1F7D]|[\u1F80-\u1F87]|[\u1F90-\u1F97]|[\u1FA0-\u1FA7]|[\u1FB0-\u1FB4]|[\u1FB6-\u1FB7]|[\u1FBE-\u1FBE]|[\u1FC2-\u1FC4]|[\u1FC6-\u1FC7]|[\u1FD0-\u1FD3]|[\u1FD6-\u1FD7]|[\u1FE0-\u1FE7]|[\u1FF2-\u1FF4]|[\u1FF6-\u1FF7]|[\u207F-\u207F]|[\u210A-\u210A]|[\u210E-\u210F]|[\u2113-\u2113]|[\u2118-\u2118]|[\u212E-\u212F]|[\u2134-\u2134]|[\uFB00-\uFB06]|[\uFB13-\uFB17]|[\uFF41-\uFF5A]/, Lt: /[\u01C5-\u01C5]|[\u01C8-\u01C8]|[\u01CB-\u01CB]|[\u01F2-\u01F2]/, Lm: /[\u02B0-\u02B8]|[\u02BB-\u02C1]|[\u02D0-\u02D1]|[\u02E0-\u02E4]|[\u037A-\u037A]|[\u0559-\u0559]|[\u0640-\u0640]|[\u06E5-\u06E6]|[\u0E46-\u0E46]|[\u0EC6-\u0EC6]|[\u3005-\u3005]|[\u3031-\u3035]|[\u309D-\u309E]|[\u30FC-\u30FE]|[\uFF70-\uFF70]|[\uFF9E-\uFF9F]/, Lo: /[\u01AA-\u01AA]|[\u01BB-\u01BB]|[\u01BE-\u01C3]|[\u03F3-\u03F3]|[\u04C0-\u04C0]|[\u05D0-\u05EA]|[\u05F0-\u05F2]|[\u0621-\u063A]|[\u0641-\u064A]|[\u0671-\u06B7]|[\u06BA-\u06BE]|[\u06C0-\u06CE]|[\u06D0-\u06D3]|[\u06D5-\u06D5]|[\u0905-\u0939]|[\u093D-\u093D]|[\u0950-\u0950]|[\u0958-\u0961]|[\u0985-\u098C]|[\u098F-\u0990]|[\u0993-\u09A8]|[\u09AA-\u09B0]|[\u09B2-\u09B2]|[\u09B6-\u09B9]|[\u09DC-\u09DD]|[\u09DF-\u09E1]|[\u09F0-\u09F1]|[\u0A05-\u0A0A]|[\u0A0F-\u0A10]|[\u0A13-\u0A28]|[\u0A2A-\u0A30]|[\u0A32-\u0A33]|[\u0A35-\u0A36]|[\u0A38-\u0A39]|[\u0A59-\u0A5C]|[\u0A5E-\u0A5E]|[\u0A72-\u0A74]|[\u0A85-\u0A8B]|[\u0A8D-\u0A8D]|[\u0A8F-\u0A91]|[\u0A93-\u0AA8]|[\u0AAA-\u0AB0]|[\u0AB2-\u0AB3]|[\u0AB5-\u0AB9]|[\u0ABD-\u0ABD]|[\u0AD0-\u0AD0]|[\u0AE0-\u0AE0]|[\u0B05-\u0B0C]|[\u0B0F-\u0B10]|[\u0B13-\u0B28]|[\u0B2A-\u0B30]|[\u0B32-\u0B33]|[\u0B36-\u0B39]|[\u0B3D-\u0B3D]|[\u0B5C-\u0B5D]|[\u0B5F-\u0B61]|[\u0B85-\u0B8A]|[\u0B8E-\u0B90]|[\u0B92-\u0B95]|[\u0B99-\u0B9A]|[\u0B9C-\u0B9C]|[\u0B9E-\u0B9F]|[\u0BA3-\u0BA4]|[\u0BA8-\u0BAA]|[\u0BAE-\u0BB5]|[\u0BB7-\u0BB9]|[\u0C05-\u0C0C]|[\u0C0E-\u0C10]|[\u0C12-\u0C28]|[\u0C2A-\u0C33]|[\u0C35-\u0C39]|[\u0C60-\u0C61]|[\u0C85-\u0C8C]|[\u0C8E-\u0C90]|[\u0C92-\u0CA8]|[\u0CAA-\u0CB3]|[\u0CB5-\u0CB9]|[\u0CDE-\u0CDE]|[\u0CE0-\u0CE1]|[\u0D05-\u0D0C]|[\u0D0E-\u0D10]|[\u0D12-\u0D28]|[\u0D2A-\u0D39]|[\u0D60-\u0D61]|[\u0E01-\u0E30]|[\u0E32-\u0E33]|[\u0E40-\u0E45]|[\u0E81-\u0E82]|[\u0E84-\u0E84]|[\u0E87-\u0E88]|[\u0E8A-\u0E8A]|[\u0E8D-\u0E8D]|[\u0E94-\u0E97]|[\u0E99-\u0E9F]|[\u0EA1-\u0EA3]|[\u0EA5-\u0EA5]|[\u0EA7-\u0EA7]|[\u0EAA-\u0EAB]|[\u0EAD-\u0EB0]|[\u0EB2-\u0EB3]|[\u0EBD-\u0EBD]|[\u0EC0-\u0EC4]|[\u0EDC-\u0EDD]|[\u0F00-\u0F00]|[\u0F40-\u0F47]|[\u0F49-\u0F69]|[\u0F88-\u0F8B]|[\u1100-\u1159]|[\u115F-\u11A2]|[\u11A8-\u11F9]|[\u2135-\u2138]|[\u3006-\u3006]|[\u3041-\u3094]|[\u30A1-\u30FA]|[\u3105-\u312C]|[\u3131-\u318E]|[\u4E00-\u9FA5]|[\uAC00-\uD7A3]|[\uF900-\uFA2D]|[\uFB1F-\uFB28]|[\uFB2A-\uFB36]|[\uFB38-\uFB3C]|[\uFB3E-\uFB3E]|[\uFB40-\uFB41]|[\uFB43-\uFB44]|[\uFB46-\uFBB1]|[\uFBD3-\uFD3D]|[\uFD50-\uFD8F]|[\uFD92-\uFDC7]|[\uFDF0-\uFDFB]|[\uFE70-\uFE72]|[\uFE74-\uFE74]|[\uFE76-\uFEFC]|[\uFF66-\uFF6F]|[\uFF71-\uFF9D]|[\uFFA0-\uFFBE]|[\uFFC2-\uFFC7]|[\uFFCA-\uFFCF]|[\uFFD2-\uFFD7]|[\uFFDA-\uFFDC]/, // Numbers Nl: /[\u2160-\u2182]|[\u3007-\u3007]|[\u3021-\u3029]/, Nd: /[\u0030-\u0039]|[\u0660-\u0669]|[\u06F0-\u06F9]|[\u0966-\u096F]|[\u09E6-\u09EF]|[\u0A66-\u0A6F]|[\u0AE6-\u0AEF]|[\u0B66-\u0B6F]|[\u0BE7-\u0BEF]|[\u0C66-\u0C6F]|[\u0CE6-\u0CEF]|[\u0D66-\u0D6F]|[\u0E50-\u0E59]|[\u0ED0-\u0ED9]|[\u0F20-\u0F29]|[\uFF10-\uFF19]/, // Marks Mn: /[\u0300-\u0345]|[\u0360-\u0361]|[\u0483-\u0486]|[\u0591-\u05A1]|[\u05A3-\u05B9]|[\u05BB-\u05BD]|[\u05BF-\u05BF]|[\u05C1-\u05C2]|[\u05C4-\u05C4]|[\u064B-\u0652]|[\u0670-\u0670]|[\u06D6-\u06DC]|[\u06DF-\u06E4]|[\u06E7-\u06E8]|[\u06EA-\u06ED]|[\u0901-\u0902]|[\u093C-\u093C]|[\u0941-\u0948]|[\u094D-\u094D]|[\u0951-\u0954]|[\u0962-\u0963]|[\u0981-\u0981]|[\u09BC-\u09BC]|[\u09C1-\u09C4]|[\u09CD-\u09CD]|[\u09E2-\u09E3]|[\u0A02-\u0A02]|[\u0A3C-\u0A3C]|[\u0A41-\u0A42]|[\u0A47-\u0A48]|[\u0A4B-\u0A4D]|[\u0A70-\u0A71]|[\u0A81-\u0A82]|[\u0ABC-\u0ABC]|[\u0AC1-\u0AC5]|[\u0AC7-\u0AC8]|[\u0ACD-\u0ACD]|[\u0B01-\u0B01]|[\u0B3C-\u0B3C]|[\u0B3F-\u0B3F]|[\u0B41-\u0B43]|[\u0B4D-\u0B4D]|[\u0B56-\u0B56]|[\u0B82-\u0B82]|[\u0BC0-\u0BC0]|[\u0BCD-\u0BCD]|[\u0C3E-\u0C40]|[\u0C46-\u0C48]|[\u0C4A-\u0C4D]|[\u0C55-\u0C56]|[\u0CBF-\u0CBF]|[\u0CC6-\u0CC6]|[\u0CCC-\u0CCD]|[\u0D41-\u0D43]|[\u0D4D-\u0D4D]|[\u0E31-\u0E31]|[\u0E34-\u0E3A]|[\u0E47-\u0E4E]|[\u0EB1-\u0EB1]|[\u0EB4-\u0EB9]|[\u0EBB-\u0EBC]|[\u0EC8-\u0ECD]|[\u0F18-\u0F19]|[\u0F35-\u0F35]|[\u0F37-\u0F37]|[\u0F39-\u0F39]|[\u0F71-\u0F7E]|[\u0F80-\u0F84]|[\u0F86-\u0F87]|[\u0F90-\u0F95]|[\u0F97-\u0F97]|[\u0F99-\u0FAD]|[\u0FB1-\u0FB7]|[\u0FB9-\u0FB9]|[\u20D0-\u20DC]|[\u20E1-\u20E1]|[\u302A-\u302F]|[\u3099-\u309A]|[\uFB1E-\uFB1E]|[\uFE20-\uFE23]/, Mc: /[\u0903-\u0903]|[\u093E-\u0940]|[\u0949-\u094C]|[\u0982-\u0983]|[\u09BE-\u09C0]|[\u09C7-\u09C8]|[\u09CB-\u09CC]|[\u09D7-\u09D7]|[\u0A3E-\u0A40]|[\u0A83-\u0A83]|[\u0ABE-\u0AC0]|[\u0AC9-\u0AC9]|[\u0ACB-\u0ACC]|[\u0B02-\u0B03]|[\u0B3E-\u0B3E]|[\u0B40-\u0B40]|[\u0B47-\u0B48]|[\u0B4B-\u0B4C]|[\u0B57-\u0B57]|[\u0B83-\u0B83]|[\u0BBE-\u0BBF]|[\u0BC1-\u0BC2]|[\u0BC6-\u0BC8]|[\u0BCA-\u0BCC]|[\u0BD7-\u0BD7]|[\u0C01-\u0C03]|[\u0C41-\u0C44]|[\u0C82-\u0C83]|[\u0CBE-\u0CBE]|[\u0CC0-\u0CC4]|[\u0CC7-\u0CC8]|[\u0CCA-\u0CCB]|[\u0CD5-\u0CD6]|[\u0D02-\u0D03]|[\u0D3E-\u0D40]|[\u0D46-\u0D48]|[\u0D4A-\u0D4C]|[\u0D57-\u0D57]|[\u0F3E-\u0F3F]|[\u0F7F-\u0F7F]/, // Punctuation, Connector Pc: /[\u005F-\u005F]|[\u203F-\u2040]|[\u30FB-\u30FB]|[\uFE33-\uFE34]|[\uFE4D-\uFE4F]|[\uFF3F-\uFF3F]|[\uFF65-\uFF65]/, // Separator, Space Zs: /[\u2000-\u200B]|[\u3000-\u3000]/, // These two are not real Unicode categories, but our useful for Ohm. // L is a combination of all the letter categories. // Ltmo is a combination of Lt, Lm, and Lo. L: /[\u0041-\u005A]|[\u00C0-\u00D6]|[\u00D8-\u00DE]|[\u0100-\u0100]|[\u0102-\u0102]|[\u0104-\u0104]|[\u0106-\u0106]|[\u0108-\u0108]|[\u010A-\u010A]|[\u010C-\u010C]|[\u010E-\u010E]|[\u0110-\u0110]|[\u0112-\u0112]|[\u0114-\u0114]|[\u0116-\u0116]|[\u0118-\u0118]|[\u011A-\u011A]|[\u011C-\u011C]|[\u011E-\u011E]|[\u0120-\u0120]|[\u0122-\u0122]|[\u0124-\u0124]|[\u0126-\u0126]|[\u0128-\u0128]|[\u012A-\u012A]|[\u012C-\u012C]|[\u012E-\u012E]|[\u0130-\u0130]|[\u0132-\u0132]|[\u0134-\u0134]|[\u0136-\u0136]|[\u0139-\u0139]|[\u013B-\u013B]|[\u013D-\u013D]|[\u013F-\u013F]|[\u0141-\u0141]|[\u0143-\u0143]|[\u0145-\u0145]|[\u0147-\u0147]|[\u014A-\u014A]|[\u014C-\u014C]|[\u014E-\u014E]|[\u0150-\u0150]|[\u0152-\u0152]|[\u0154-\u0154]|[\u0156-\u0156]|[\u0158-\u0158]|[\u015A-\u015A]|[\u015C-\u015C]|[\u015E-\u015E]|[\u0160-\u0160]|[\u0162-\u0162]|[\u0164-\u0164]|[\u0166-\u0166]|[\u0168-\u0168]|[\u016A-\u016A]|[\u016C-\u016C]|[\u016E-\u016E]|[\u0170-\u0170]|[\u0172-\u0172]|[\u0174-\u0174]|[\u0176-\u0176]|[\u0178-\u0179]|[\u017B-\u017B]|[\u017D-\u017D]|[\u0181-\u0182]|[\u0184-\u0184]|[\u0186-\u0187]|[\u0189-\u018B]|[\u018E-\u0191]|[\u0193-\u0194]|[\u0196-\u0198]|[\u019C-\u019D]|[\u019F-\u01A0]|[\u01A2-\u01A2]|[\u01A4-\u01A4]|[\u01A6-\u01A7]|[\u01A9-\u01A9]|[\u01AC-\u01AC]|[\u01AE-\u01AF]|[\u01B1-\u01B3]|[\u01B5-\u01B5]|[\u01B7-\u01B8]|[\u01BC-\u01BC]|[\u01C4-\u01C4]|[\u01C7-\u01C7]|[\u01CA-\u01CA]|[\u01CD-\u01CD]|[\u01CF-\u01CF]|[\u01D1-\u01D1]|[\u01D3-\u01D3]|[\u01D5-\u01D5]|[\u01D7-\u01D7]|[\u01D9-\u01D9]|[\u01DB-\u01DB]|[\u01DE-\u01DE]|[\u01E0-\u01E0]|[\u01E2-\u01E2]|[\u01E4-\u01E4]|[\u01E6-\u01E6]|[\u01E8-\u01E8]|[\u01EA-\u01EA]|[\u01EC-\u01EC]|[\u01EE-\u01EE]|[\u01F1-\u01F1]|[\u01F4-\u01F4]|[\u01FA-\u01FA]|[\u01FC-\u01FC]|[\u01FE-\u01FE]|[\u0200-\u0200]|[\u0202-\u0202]|[\u0204-\u0204]|[\u0206-\u0206]|[\u0208-\u0208]|[\u020A-\u020A]|[\u020C-\u020C]|[\u020E-\u020E]|[\u0210-\u0210]|[\u0212-\u0212]|[\u0214-\u0214]|[\u0216-\u0216]|[\u0386-\u0386]|[\u0388-\u038A]|[\u038C-\u038C]|[\u038E-\u038F]|[\u0391-\u03A1]|[\u03A3-\u03AB]|[\u03D2-\u03D4]|[\u03DA-\u03DA]|[\u03DC-\u03DC]|[\u03DE-\u03DE]|[\u03E0-\u03E0]|[\u03E2-\u03E2]|[\u03E4-\u03E4]|[\u03E6-\u03E6]|[\u03E8-\u03E8]|[\u03EA-\u03EA]|[\u03EC-\u03EC]|[\u03EE-\u03EE]|[\u0401-\u040C]|[\u040E-\u042F]|[\u0460-\u0460]|[\u0462-\u0462]|[\u0464-\u0464]|[\u0466-\u0466]|[\u0468-\u0468]|[\u046A-\u046A]|[\u046C-\u046C]|[\u046E-\u046E]|[\u0470-\u0470]|[\u0472-\u0472]|[\u0474-\u0474]|[\u0476-\u0476]|[\u0478-\u0478]|[\u047A-\u047A]|[\u047C-\u047C]|[\u047E-\u047E]|[\u0480-\u0480]|[\u0490-\u0490]|[\u0492-\u0492]|[\u0494-\u0494]|[\u0496-\u0496]|[\u0498-\u0498]|[\u049A-\u049A]|[\u049C-\u049C]|[\u049E-\u049E]|[\u04A0-\u04A0]|[\u04A2-\u04A2]|[\u04A4-\u04A4]|[\u04A6-\u04A6]|[\u04A8-\u04A8]|[\u04AA-\u04AA]|[\u04AC-\u04AC]|[\u04AE-\u04AE]|[\u04B0-\u04B0]|[\u04B2-\u04B2]|[\u04B4-\u04B4]|[\u04B6-\u04B6]|[\u04B8-\u04B8]|[\u04BA-\u04BA]|[\u04BC-\u04BC]|[\u04BE-\u04BE]|[\u04C1-\u04C1]|[\u04C3-\u04C3]|[\u04C7-\u04C7]|[\u04CB-\u04CB]|[\u04D0-\u04D0]|[\u04D2-\u04D2]|[\u04D4-\u04D4]|[\u04D6-\u04D6]|[\u04D8-\u04D8]|[\u04DA-\u04DA]|[\u04DC-\u04DC]|[\u04DE-\u04DE]|[\u04E0-\u04E0]|[\u04E2-\u04E2]|[\u04E4-\u04E4]|[\u04E6-\u04E6]|[\u04E8-\u04E8]|[\u04EA-\u04EA]|[\u04EE-\u04EE]|[\u04F0-\u04F0]|[\u04F2-\u04F2]|[\u04F4-\u04F4]|[\u04F8-\u04F8]|[\u0531-\u0556]|[\u10A0-\u10C5]|[\u1E00-\u1E00]|[\u1E02-\u1E02]|[\u1E04-\u1E04]|[\u1E06-\u1E06]|[\u1E08-\u1E08]|[\u1E0A-\u1E0A]|[\u1E0C-\u1E0C]|[\u1E0E-\u1E0E]|[\u1E10-\u1E10]|[\u1E12-\u1E12]|[\u1E14-\u1E14]|[\u1E16-\u1E16]|[\u1E18-\u1E18]|[\u1E1A-\u1E1A]|[\u1E1C-\u1E1C]|[\u1E1E-\u1E1E]|[\u1E20-\u1E20]|[\u1E22-\u1E22]|[\u1E24-\u1E24]|[\u1E26-\u1E26]|[\u1E28-\u1E28]|[\u1E2A-\u1E2A]|[\u1E2C-\u1E2C]|[\u1E2E-\u1E2E]|[\u1E30-\u1E30]|[\u1E32-\u1E32]|[\u1E34-\u1E34]|[\u1E36-\u1E36]|[\u1E38-\u1E38]|[\u1E3A-\u1E3A]|[\u1E3C-\u1E3C]|[\u1E3E-\u1E3E]|[\u1E40-\u1E40]|[\u1E42-\u1E42]|[\u1E44-\u1E44]|[\u1E46-\u1E46]|[\u1E48-\u1E48]|[\u1E4A-\u1E4A]|[\u1E4C-\u1E4C]|[\u1E4E-\u1E4E]|[\u1E50-\u1E50]|[\u1E52-\u1E52]|[\u1E54-\u1E54]|[\u1E56-\u1E56]|[\u1E58-\u1E58]|[\u1E5A-\u1E5A]|[\u1E5C-\u1E5C]|[\u1E5E-\u1E5E]|[\u1E60-\u1E60]|[\u1E62-\u1E62]|[\u1E64-\u1E64]|[\u1E66-\u1E66]|[\u1E68-\u1E68]|[\u1E6A-\u1E6A]|[\u1E6C-\u1E6C]|[\u1E6E-\u1E6E]|[\u1E70-\u1E70]|[\u1E72-\u1E72]|[\u1E74-\u1E74]|[\u1E76-\u1E76]|[\u1E78-\u1E78]|[\u1E7A-\u1E7A]|[\u1E7C-\u1E7C]|[\u1E7E-\u1E7E]|[\u1E80-\u1E80]|[\u1E82-\u1E82]|[\u1E84-\u1E84]|[\u1E86-\u1E86]|[\u1E88-\u1E88]|[\u1E8A-\u1E8A]|[\u1E8C-\u1E8C]|[\u1E8E-\u1E8E]|[\u1E90-\u1E90]|[\u1E92-\u1E92]|[\u1E94-\u1E94]|[\u1EA0-\u1EA0]|[\u1EA2-\u1EA2]|[\u1EA4-\u1EA4]|[\u1EA6-\u1EA6]|[\u1EA8-\u1EA8]|[\u1EAA-\u1EAA]|[\u1EAC-\u1EAC]|[\u1EAE-\u1EAE]|[\u1EB0-\u1EB0]|[\u1EB2-\u1EB2]|[\u1EB4-\u1EB4]|[\u1EB6-\u1EB6]|[\u1EB8-\u1EB8]|[\u1EBA-\u1EBA]|[\u1EBC-\u1EBC]|[\u1EBE-\u1EBE]|[\u1EC0-\u1EC0]|[\u1EC2-\u1EC2]|[\u1EC4-\u1EC4]|[\u1EC6-\u1EC6]|[\u1EC8-\u1EC8]|[\u1ECA-\u1ECA]|[\u1ECC-\u1ECC]|[\u1ECE-\u1ECE]|[\u1ED0-\u1ED0]|[\u1ED2-\u1ED2]|[\u1ED4-\u1ED4]|[\u1ED6-\u1ED6]|[\u1ED8-\u1ED8]|[\u1EDA-\u1EDA]|[\u1EDC-\u1EDC]|[\u1EDE-\u1EDE]|[\u1EE0-\u1EE0]|[\u1EE2-\u1EE2]|[\u1EE4-\u1EE4]|[\u1EE6-\u1EE6]|[\u1EE8-\u1EE8]|[\u1EEA-\u1EEA]|[\u1EEC-\u1EEC]|[\u1EEE-\u1EEE]|[\u1EF0-\u1EF0]|[\u1EF2-\u1EF2]|[\u1EF4-\u1EF4]|[\u1EF6-\u1EF6]|[\u1EF8-\u1EF8]|[\u1F08-\u1F0F]|[\u1F18-\u1F1D]|[\u1F28-\u1F2F]|[\u1F38-\u1F3F]|[\u1F48-\u1F4D]|[\u1F59-\u1F59]|[\u1F5B-\u1F5B]|[\u1F5D-\u1F5D]|[\u1F5F-\u1F5F]|[\u1F68-\u1F6F]|[\u1F88-\u1F8F]|[\u1F98-\u1F9F]|[\u1FA8-\u1FAF]|[\u1FB8-\u1FBC]|[\u1FC8-\u1FCC]|[\u1FD8-\u1FDB]|[\u1FE8-\u1FEC]|[\u1FF8-\u1FFC]|[\u2102-\u2102]|[\u2107-\u2107]|[\u210B-\u210D]|[\u2110-\u2112]|[\u2115-\u2115]|[\u2119-\u211D]|[\u2124-\u2124]|[\u2126-\u2126]|[\u2128-\u2128]|[\u212A-\u212D]|[\u2130-\u2131]|[\u2133-\u2133]|[\uFF21-\uFF3A]|[\u0061-\u007A]|[\u00AA-\u00AA]|[\u00B5-\u00B5]|[\u00BA-\u00BA]|[\u00DF-\u00F6]|[\u00F8-\u00FF]|[\u0101-\u0101]|[\u0103-\u0103]|[\u0105-\u0105]|[\u0107-\u0107]|[\u0109-\u0109]|[\u010B-\u010B]|[\u010D-\u010D]|[\u010F-\u010F]|[\u0111-\u0111]|[\u0113-\u0113]|[\u0115-\u0115]|[\u0117-\u0117]|[\u0119-\u0119]|[\u011B-\u011B]|[\u011D-\u011D]|[\u011F-\u011F]|[\u0121-\u0121]|[\u0123-\u0123]|[\u0125-\u0125]|[\u0127-\u0127]|[\u0129-\u0129]|[\u012B-\u012B]|[\u012D-\u012D]|[\u012F-\u012F]|[\u0131-\u0131]|[\u0133-\u0133]|[\u0135-\u0135]|[\u0137-\u0138]|[\u013A-\u013A]|[\u013C-\u013C]|[\u013E-\u013E]|[\u0140-\u0140]|[\u0142-\u0142]|[\u0144-\u0144]|[\u0146-\u0146]|[\u0148-\u0149]|[\u014B-\u014B]|[\u014D-\u014D]|[\u014F-\u014F]|[\u0151-\u0151]|[\u0153-\u0153]|[\u0155-\u0155]|[\u0157-\u0157]|[\u0159-\u0159]|[\u015B-\u015B]|[\u015D-\u015D]|[\u015F-\u015F]|[\u0161-\u0161]|[\u0163-\u0163]|[\u0165-\u0165]|[\u0167-\u0167]|[\u0169-\u0169]|[\u016B-\u016B]|[\u016D-\u016D]|[\u016F-\u016F]|[\u0171-\u0171]|[\u0173-\u0173]|[\u0175-\u0175]|[\u0177-\u0177]|[\u017A-\u017A]|[\u017C-\u017C]|[\u017E-\u0180]|[\u0183-\u0183]|[\u0185-\u0185]|[\u0188-\u0188]|[\u018C-\u018D]|[\u0192-\u0192]|[\u0195-\u0195]|[\u0199-\u019B]|[\u019E-\u019E]|[\u01A1-\u01A1]|[\u01A3-\u01A3]|[\u01A5-\u01A5]|[\u01A8-\u01A8]|[\u01AB-\u01AB]|[\u01AD-\u01AD]|[\u01B0-\u01B0]|[\u01B4-\u01B4]|[\u01B6-\u01B6]|[\u01B9-\u01BA]|[\u01BD-\u01BD]|[\u01C6-\u01C6]|[\u01C9-\u01C9]|[\u01CC-\u01CC]|[\u01CE-\u01CE]|[\u01D0-\u01D0]|[\u01D2-\u01D2]|[\u01D4-\u01D4]|[\u01D6-\u01D6]|[\u01D8-\u01D8]|[\u01DA-\u01DA]|[\u01DC-\u01DD]|[\u01DF-\u01DF]|[\u01E1-\u01E1]|[\u01E3-\u01E3]|[\u01E5-\u01E5]|[\u01E7-\u01E7]|[\u01E9-\u01E9]|[\u01EB-\u01EB]|[\u01ED-\u01ED]|[\u01EF-\u01F0]|[\u01F3-\u01F3]|[\u01F5-\u01F5]|[\u01FB-\u01FB]|[\u01FD-\u01FD]|[\u01FF-\u01FF]|[\u0201-\u0201]|[\u0203-\u0203]|[\u0205-\u0205]|[\u0207-\u0207]|[\u0209-\u0209]|[\u020B-\u020B]|[\u020D-\u020D]|[\u020F-\u020F]|[\u0211-\u0211]|[\u0213-\u0213]|[\u0215-\u0215]|[\u0217-\u0217]|[\u0250-\u02A8]|[\u0390-\u0390]|[\u03AC-\u03CE]|[\u03D0-\u03D1]|[\u03D5-\u03D6]|[\u03E3-\u03E3]|[\u03E5-\u03E5]|[\u03E7-\u03E7]|[\u03E9-\u03E9]|[\u03EB-\u03EB]|[\u03ED-\u03ED]|[\u03EF-\u03F2]|[\u0430-\u044F]|[\u0451-\u045C]|[\u045E-\u045F]|[\u0461-\u0461]|[\u0463-\u0463]|[\u0465-\u0465]|[\u0467-\u0467]|[\u0469-\u0469]|[\u046B-\u046B]|[\u046D-\u046D]|[\u046F-\u046F]|[\u0471-\u0471]|[\u0473-\u0473]|[\u0475-\u0475]|[\u0477-\u0477]|[\u0479-\u0479]|[\u047B-\u047B]|[\u047D-\u047D]|[\u047F-\u047F]|[\u0481-\u0481]|[\u0491-\u0491]|[\u0493-\u0493]|[\u0495-\u0495]|[\u0497-\u0497]|[\u0499-\u0499]|[\u049B-\u049B]|[\u049D-\u049D]|[\u049F-\u049F]|[\u04A1-\u04A1]|[\u04A3-\u04A3]|[\u04A5-\u04A5]|[\u04A7-\u04A7]|[\u04A9-\u04A9]|[\u04AB-\u04AB]|[\u04AD-\u04AD]|[\u04AF-\u04AF]|[\u04B1-\u04B1]|[\u04B3-\u04B3]|[\u04B5-\u04B5]|[\u04B7-\u04B7]|[\u04B9-\u04B9]|[\u04BB-\u04BB]|[\u04BD-\u04BD]|[\u04BF-\u04BF]|[\u04C2-\u04C2]|[\u04C4-\u04C4]|[\u04C8-\u04C8]|[\u04CC-\u04CC]|[\u04D1-\u04D1]|[\u04D3-\u04D3]|[\u04D5-\u04D5]|[\u04D7-\u04D7]|[\u04D9-\u04D9]|[\u04DB-\u04DB]|[\u04DD-\u04DD]|[\u04DF-\u04DF]|[\u04E1-\u04E1]|[\u04E3-\u04E3]|[\u04E5-\u04E5]|[\u04E7-\u04E7]|[\u04E9-\u04E9]|[\u04EB-\u04EB]|[\u04EF-\u04EF]|[\u04F1-\u04F1]|[\u04F3-\u04F3]|[\u04F5-\u04F5]|[\u04F9-\u04F9]|[\u0561-\u0587]|[\u10D0-\u10F6]|[\u1E01-\u1E01]|[\u1E03-\u1E03]|[\u1E05-\u1E05]|[\u1E07-\u1E07]|[\u1E09-\u1E09]|[\u1E0B-\u1E0B]|[\u1E0D-\u1E0D]|[\u1E0F-\u1E0F]|[\u1E11-\u1E11]|[\u1E13-\u1E13]|[\u1E15-\u1E15]|[\u1E17-\u1E17]|[\u1E19-\u1E19]|[\u1E1B-\u1E1B]|[\u1E1D-\u1E1D]|[\u1E1F-\u1E1F]|[\u1E21-\u1E21]|[\u1E23-\u1E23]|[\u1E25-\u1E25]|[\u1E27-\u1E27]|[\u1E29-\u1E29]|[\u1E2B-\u1E2B]|[\u1E2D-\u1E2D]|[\u1E2F-\u1E2F]|[\u1E31-\u1E31]|[\u1E33-\u1E33]|[\u1E35-\u1E35]|[\u1E37-\u1E37]|[\u1E39-\u1E39]|[\u1E3B-\u1E3B]|[\u1E3D-\u1E3D]|[\u1E3F-\u1E3F]|[\u1E41-\u1E41]|[\u1E43-\u1E43]|[\u1E45-\u1E45]|[\u1E47-\u1E47]|[\u1E49-\u1E49]|[\u1E4B-\u1E4B]|[\u1E4D-\u1E4D]|[\u1E4F-\u1E4F]|[\u1E51-\u1E51]|[\u1E53-\u1E53]|[\u1E55-\u1E55]|[\u1E57-\u1E57]|[\u1E59-\u1E59]|[\u1E5B-\u1E5B]|[\u1E5D-\u1E5D]|[\u1E5F-\u1E5F]|[\u1E61-\u1E61]|[\u1E63-\u1E63]|[\u1E65-\u1E65]|[\u1E67-\u1E67]|[\u1E69-\u1E69]|[\u1E6B-\u1E6B]|[\u1E6D-\u1E6D]|[\u1E6F-\u1E6F]|[\u1E71-\u1E71]|[\u1E73-\u1E73]|[\u1E75-\u1E75]|[\u1E77-\u1E77]|[\u1E79-\u1E79]|[\u1E7B-\u1E7B]|[\u1E7D-\u1E7D]|[\u1E7F-\u1E7F]|[\u1E81-\u1E81]|[\u1E83-\u1E83]|[\u1E85-\u1E85]|[\u1E87-\u1E87]|[\u1E89-\u1E89]|[\u1E8B-\u1E8B]|[\u1E8D-\u1E8D]|[\u1E8F-\u1E8F]|[\u1E91-\u1E91]|[\u1E93-\u1E93]|[\u1E95-\u1E9B]|[\u1EA1-\u1EA1]|[\u1EA3-\u1EA3]|[\u1EA5-\u1EA5]|[\u1EA7-\u1EA7]|[\u1EA9-\u1EA9]|[\u1EAB-\u1EAB]|[\u1EAD-\u1EAD]|[\u1EAF-\u1EAF]|[\u1EB1-\u1EB1]|[\u1EB3-\u1EB3]|[\u1EB5-\u1EB5]|[\u1EB7-\u1EB7]|[\u1EB9-\u1EB9]|[\u1EBB-\u1EBB]|[\u1EBD-\u1EBD]|[\u1EBF-\u1EBF]|[\u1EC1-\u1EC1]|[\u1EC3-\u1EC3]|[\u1EC5-\u1EC5]|[\u1EC7-\u1EC7]|[\u1EC9-\u1EC9]|[\u1ECB-\u1ECB]|[\u1ECD-\u1ECD]|[\u1ECF-\u1ECF]|[\u1ED1-\u1ED1]|[\u1ED3-\u1ED3]|[\u1ED5-\u1ED5]|[\u1ED7-\u1ED7]|[\u1ED9-\u1ED9]|[\u1EDB-\u1EDB]|[\u1EDD-\u1EDD]|[\u1EDF-\u1EDF]|[\u1EE1-\u1EE1]|[\u1EE3-\u1EE3]|[\u1EE5-\u1EE5]|[\u1EE7-\u1EE7]|[\u1EE9-\u1EE9]|[\u1EEB-\u1EEB]|[\u1EED-\u1EED]|[\u1EEF-\u1EEF]|[\u1EF1-\u1EF1]|[\u1EF3-\u1EF3]|[\u1EF5-\u1EF5]|[\u1EF7-\u1EF7]|[\u1EF9-\u1EF9]|[\u1F00-\u1F07]|[\u1F10-\u1F15]|[\u1F20-\u1F27]|[\u1F30-\u1F37]|[\u1F40-\u1F45]|[\u1F50-\u1F57]|[\u1F60-\u1F67]|[\u1F70-\u1F7D]|[\u1F80-\u1F87]|[\u1F90-\u1F97]|[\u1FA0-\u1FA7]|[\u1FB0-\u1FB4]|[\u1FB6-\u1FB7]|[\u1FBE-\u1FBE]|[\u1FC2-\u1FC4]|[\u1FC6-\u1FC7]|[\u1FD0-\u1FD3]|[\u1FD6-\u1FD7]|[\u1FE0-\u1FE7]|[\u1FF2-\u1FF4]|[\u1FF6-\u1FF7]|[\u207F-\u207F]|[\u210A-\u210A]|[\u210E-\u210F]|[\u2113-\u2113]|[\u2118-\u2118]|[\u212E-\u212F]|[\u2134-\u2134]|[\uFB00-\uFB06]|[\uFB13-\uFB17]|[\uFF41-\uFF5A]|[\u01C5-\u01C5]|[\u01C8-\u01C8]|[\u01CB-\u01CB]|[\u01F2-\u01F2]|[\u02B0-\u02B8]|[\u02BB-\u02C1]|[\u02D0-\u02D1]|[\u02E0-\u02E4]|[\u037A-\u037A]|[\u0559-\u0559]|[\u0640-\u0640]|[\u06E5-\u06E6]|[\u0E46-\u0E46]|[\u0EC6-\u0EC6]|[\u3005-\u3005]|[\u3031-\u3035]|[\u309D-\u309E]|[\u30FC-\u30FE]|[\uFF70-\uFF70]|[\uFF9E-\uFF9F]|[\u01AA-\u01AA]|[\u01BB-\u01BB]|[\u01BE-\u01C3]|[\u03F3-\u03F3]|[\u04C0-\u04C0]|[\u05D0-\u05EA]|[\u05F0-\u05F2]|[\u0621-\u063A]|[\u0641-\u064A]|[\u0671-\u06B7]|[\u06BA-\u06BE]|[\u06C0-\u06CE]|[\u06D0-\u06D3]|[\u06D5-\u06D5]|[\u0905-\u0939]|[\u093D-\u093D]|[\u0950-\u0950]|[\u0958-\u0961]|[\u0985-\u098C]|[\u098F-\u0990]|[\u0993-\u09A8]|[\u09AA-\u09B0]|[\u09B2-\u09B2]|[\u09B6-\u09B9]|[\u09DC-\u09DD]|[\u09DF-\u09E1]|[\u09F0-\u09F1]|[\u0A05-\u0A0A]|[\u0A0F-\u0A10]|[\u0A13-\u0A28]|[\u0A2A-\u0A30]|[\u0A32-\u0A33]|[\u0A35-\u0A36]|[\u0A38-\u0A39]|[\u0A59-\u0A5C]|[\u0A5E-\u0A5E]|[\u0A72-\u0A74]|[\u0A85-\u0A8B]|[\u0A8D-\u0A8D]|[\u0A8F-\u0A91]|[\u0A93-\u0AA8]|[\u0AAA-\u0AB0]|[\u0AB2-\u0AB3]|[\u0AB5-\u0AB9]|[\u0ABD-\u0ABD]|[\u0AD0-\u0AD0]|[\u0AE0-\u0AE0]|[\u0B05-\u0B0C]|[\u0B0F-\u0B10]|[\u0B13-\u0B28]|[\u0B2A-\u0B30]|[\u0B32-\u0B33]|[\u0B36-\u0B39]|[\u0B3D-\u0B3D]|[\u0B5C-\u0B5D]|[\u0B5F-\u0B61]|[\u0B85-\u0B8A]|[\u0B8E-\u0B90]|[\u0B92-\u0B95]|[\u0B99-\u0B9A]|[\u0B9C-\u0B9C]|[\u0B9E-\u0B9F]|[\u0BA3-\u0BA4]|[\u0BA8-\u0BAA]|[\u0BAE-\u0BB5]|[\u0BB7-\u0BB9]|[\u0C05-\u0C0C]|[\u0C0E-\u0C10]|[\u0C12-\u0C28]|[\u0C2A-\u0C33]|[\u0C35-\u0C39]|[\u0C60-\u0C61]|[\u0C85-\u0C8C]|[\u0C8E-\u0C90]|[\u0C92-\u0CA8]|[\u0CAA-\u0CB3]|[\u0CB5-\u0CB9]|[\u0CDE-\u0CDE]|[\u0CE0-\u0CE1]|[\u0D05-\u0D0C]|[\u0D0E-\u0D10]|[\u0D12-\u0D28]|[\u0D2A-\u0D39]|[\u0D60-\u0D61]|[\u0E01-\u0E30]|[\u0E32-\u0E33]|[\u0E40-\u0E45]|[\u0E81-\u0E82]|[\u0E84-\u0E84]|[\u0E87-\u0E88]|[\u0E8A-\u0E8A]|[\u0E8D-\u0E8D]|[\u0E94-\u0E97]|[\u0E99-\u0E9F]|[\u0EA1-\u0EA3]|[\u0EA5-\u0EA5]|[\u0EA7-\u0EA7]|[\u0EAA-\u0EAB]|[\u0EAD-\u0EB0]|[\u0EB2-\u0EB3]|[\u0EBD-\u0EBD]|[\u0EC0-\u0EC4]|[\u0EDC-\u0EDD]|[\u0F00-\u0F00]|[\u0F40-\u0F47]|[\u0F49-\u0F69]|[\u0F88-\u0F8B]|[\u1100-\u1159]|[\u115F-\u11A2]|[\u11A8-\u11F9]|[\u2135-\u2138]|[\u3006-\u3006]|[\u3041-\u3094]|[\u30A1-\u30FA]|[\u3105-\u312C]|[\u3131-\u318E]|[\u4E00-\u9FA5]|[\uAC00-\uD7A3]|[\uF900-\uFA2D]|[\uFB1F-\uFB28]|[\uFB2A-\uFB36]|[\uFB38-\uFB3C]|[\uFB3E-\uFB3E]|[\uFB40-\uFB41]|[\uFB43-\uFB44]|[\uFB46-\uFBB1]|[\uFBD3-\uFD3D]|[\uFD50-\uFD8F]|[\uFD92-\uFDC7]|[\uFDF0-\uFDFB]|[\uFE70-\uFE72]|[\uFE74-\uFE74]|[\uFE76-\uFEFC]|[\uFF66-\uFF6F]|[\uFF71-\uFF9D]|[\uFFA0-\uFFBE]|[\uFFC2-\uFFC7]|[\uFFCA-\uFFCF]|[\uFFD2-\uFFD7]|[\uFFDA-\uFFDC]/, Ltmo: /[\u01C5-\u01C5]|[\u01C8-\u01C8]|[\u01CB-\u01CB]|[\u01F2-\u01F2][\u02B0-\u02B8]|[\u02BB-\u02C1]|[\u02D0-\u02D1]|[\u02E0-\u02E4]|[\u037A-\u037A]|[\u0559-\u0559]|[\u0640-\u0640]|[\u06E5-\u06E6]|[\u0E46-\u0E46]|[\u0EC6-\u0EC6]|[\u3005-\u3005]|[\u3031-\u3035]|[\u309D-\u309E]|[\u30FC-\u30FE]|[\uFF70-\uFF70]|[\uFF9E-\uFF9F][\u01AA-\u01AA]|[\u01BB-\u01BB]|[\u01BE-\u01C3]|[\u03F3-\u03F3]|[\u04C0-\u04C0]|[\u05D0-\u05EA]|[\u05F0-\u05F2]|[\u0621-\u063A]|[\u0641-\u064A]|[\u0671-\u06B7]|[\u06BA-\u06BE]|[\u06C0-\u06CE]|[\u06D0-\u06D3]|[\u06D5-\u06D5]|[\u0905-\u0939]|[\u093D-\u093D]|[\u0950-\u0950]|[\u0958-\u0961]|[\u0985-\u098C]|[\u098F-\u0990]|[\u0993-\u09A8]|[\u09AA-\u09B0]|[\u09B2-\u09B2]|[\u09B6-\u09B9]|[\u09DC-\u09DD]|[\u09DF-\u09E1]|[\u09F0-\u09F1]|[\u0A05-\u0A0A]|[\u0A0F-\u0A10]|[\u0A13-\u0A28]|[\u0A2A-\u0A30]|[\u0A32-\u0A33]|[\u0A35-\u0A36]|[\u0A38-\u0A39]|[\u0A59-\u0A5C]|[\u0A5E-\u0A5E]|[\u0A72-\u0A74]|[\u0A85-\u0A8B]|[\u0A8D-\u0A8D]|[\u0A8F-\u0A91]|[\u0A93-\u0AA8]|[\u0AAA-\u0AB0]|[\u0AB2-\u0AB3]|[\u0AB5-\u0AB9]|[\u0ABD-\u0ABD]|[\u0AD0-\u0AD0]|[\u0AE0-\u0AE0]|[\u0B05-\u0B0C]|[\u0B0F-\u0B10]|[\u0B13-\u0B28]|[\u0B2A-\u0B30]|[\u0B32-\u0B33]|[\u0B36-\u0B39]|[\u0B3D-\u0B3D]|[\u0B5C-\u0B5D]|[\u0B5F-\u0B61]|[\u0B85-\u0B8A]|[\u0B8E-\u0B90]|[\u0B92-\u0B95]|[\u0B99-\u0B9A]|[\u0B9C-\u0B9C]|[\u0B9E-\u0B9F]|[\u0BA3-\u0BA4]|[\u0BA8-\u0BAA]|[\u0BAE-\u0BB5]|[\u0BB7-\u0BB9]|[\u0C05-\u0C0C]|[\u0C0E-\u0C10]|[\u0C12-\u0C28]|[\u0C2A-\u0C33]|[\u0C35-\u0C39]|[\u0C60-\u0C61]|[\u0C85-\u0C8C]|[\u0C8E-\u0C90]|[\u0C92-\u0CA8]|[\u0CAA-\u0CB3]|[\u0CB5-\u0CB9]|[\u0CDE-\u0CDE]|[\u0CE0-\u0CE1]|[\u0D05-\u0D0C]|[\u0D0E-\u0D10]|[\u0D12-\u0D28]|[\u0D2A-\u0D39]|[\u0D60-\u0D61]|[\u0E01-\u0E30]|[\u0E32-\u0E33]|[\u0E40-\u0E45]|[\u0E81-\u0E82]|[\u0E84-\u0E84]|[\u0E87-\u0E88]|[\u0E8A-\u0E8A]|[\u0E8D-\u0E8D]|[\u0E94-\u0E97]|[\u0E99-\u0E9F]|[\u0EA1-\u0EA3]|[\u0EA5-\u0EA5]|[\u0EA7-\u0EA7]|[\u0EAA-\u0EAB]|[\u0EAD-\u0EB0]|[\u0EB2-\u0EB3]|[\u0EBD-\u0EBD]|[\u0EC0-\u0EC4]|[\u0EDC-\u0EDD]|[\u0F00-\u0F00]|[\u0F40-\u0F47]|[\u0F49-\u0F69]|[\u0F88-\u0F8B]|[\u1100-\u1159]|[\u115F-\u11A2]|[\u11A8-\u11F9]|[\u2135-\u2138]|[\u3006-\u3006]|[\u3041-\u3094]|[\u30A1-\u30FA]|[\u3105-\u312C]|[\u3131-\u318E]|[\u4E00-\u9FA5]|[\uAC00-\uD7A3]|[\uF900-\uFA2D]|[\uFB1F-\uFB28]|[\uFB2A-\uFB36]|[\uFB38-\uFB3C]|[\uFB3E-\uFB3E]|[\uFB40-\uFB41]|[\uFB43-\uFB44]|[\uFB46-\uFBB1]|[\uFBD3-\uFD3D]|[\uFD50-\uFD8F]|[\uFD92-\uFDC7]|[\uFDF0-\uFDFB]|[\uFE70-\uFE72]|[\uFE74-\uFE74]|[\uFE76-\uFEFC]|[\uFF66-\uFF6F]|[\uFF71-\uFF9D]|[\uFFA0-\uFFBE]|[\uFFC2-\uFFC7]|[\uFFCA-\uFFCF]|[\uFFD2-\uFFD7]|[\uFFDA-\uFFDC]/ }; },{}]},{},[3])(3) });