@dbml/core 2.2.0 → 2.4.0

package/lib/parse/dbml/test_multiline.js

@@ -1,53 +0,0 @@
-"use strict";
-
-var fs = require('fs');
-
-var pegjsRequire = require('pegjs-require-import');
-
-var parser = pegjsRequire('./multiline_string.pegjs', {
-  format: 'commonjs',
-  dependencies: {
-    _: 'lodash'
-  }
-});
-var content = fs.readFileSync('src/parse/dbml/multiline_content.txt', 'utf-8');
-var rawStr = parser.parse(content);
-console.log(rawStr);
-rawStr = rawStr.replace(/\\[\n|\r\n]?/g, '');
-var lines = rawStr.split(/[\n|\r\n]/);
-console.log(lines);
-
-var leadingSpaces = function leadingSpaces(str) {
-  var i = 0;
-
-  while (i < str.length && str[i] === ' ') {
-    i += 1;
-  }
-
-  return i;
-};
-
-var minLeadingSpaces = lines.filter(function (line) {
-  return line.replace(/\s+/g, '');
-}).reduce(function (acc, cur) {
-  return Math.min(acc, leadingSpaces(cur));
-}, Number.MAX_SAFE_INTEGER);
-lines = lines.map(function (line) {
-  return line ? line.slice(minLeadingSpaces) : line;
-});
-
-var countLeadingEmptyLine = function countLeadingEmptyLine(lines) {
-  var i = 0;
-
-  while (i < lines.length && !lines[i].replace(/\s+/g, '')) {
-    i += 1;
-  }
-
-  return i;
-};
-
-lines.splice(0, countLeadingEmptyLine(lines));
-lines.splice(lines.length - countLeadingEmptyLine(lines.slice().reverse()));
-var finalStr = lines.join('\n');
-console.log('==========================================================');
-console.log(finalStr);

package/lib/parse/dbml/test_parser1.js

@@ -1,16 +0,0 @@
-"use strict";
-
-var fs = require('fs');
-
-var pegjsRequire = require('pegjs-require-import');
-
-var parser = pegjsRequire('./parser.pegjs', {
-  format: 'commonjs',
-  dependencies: {
-    _: 'lodash'
-  }
-});
-var content = fs.readFileSync('src/parse/dbml/parser1_content.txt', 'utf-8');
-var res = parser.parse(content);
-fs.writeFileSync('src/parse/dbml/parser1.json', JSON.stringify(res, null, 2));
-console.log(res);

package/lib/parse/mssql/base_utils.js

@@ -1,28 +0,0 @@
-"use strict";
-
-var P = require('parsimmon');
-
-var wss = require('./whitespaces');
-
-exports.word = function (string) {
-  return P.string(string).skip(wss).desc("\"".concat(string, "\""));
-};
-
-function replaceWhitespaceWithRegexp(regexp) {
-  var string = String(regexp);
-  string = string.replace(/[\s]+/g, '[^\\S\\r]+');
-  var lastSlash = string.lastIndexOf('/');
-  return new RegExp(string.slice(1, lastSlash), string.slice(lastSlash + 1));
-}
-
-exports.keyword = function (regexp) {
-  var multiword = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var newRegexp = regexp;
-  var desc = regexp.source;
-
-  if (multiword) {
-    newRegexp = replaceWhitespaceWithRegexp(regexp);
-  }
-
-  return P.regexp(newRegexp).skip(wss).desc("\"".concat(desc, "\""));
-};

package/lib/parse/mssql/composite_parsers.js

@@ -1,109 +0,0 @@
-"use strict";
-
-var P = require('parsimmon');
-
-var _require = require('./utils'),
-    makeList = _require.makeList,
-    streamline = _require.streamline;
-
-var BP = require('./base_parsers');
-
-var wss = require('./whitespaces');
-
-var Lang = P.createLanguage({
-  pIgnore: function pIgnore() {
-    return P.regex(/[^;]+/);
-  },
-  pColumnNames: function pColumnNames(r) {
-    return makeList(P.seq(r.pIdentifier, r.pKeywordAscOrDesc.fallback(null)).map(function (value) {
-      return value[0];
-    })).desc('list of column names');
-  },
-  pDotDelimitedName: function pDotDelimitedName(r) {
-    return P.sepBy1(r.pIdentifier, P.string('.')).desc('dot delimited identifier');
-  },
-  pOptionList: function pOptionList(r) {
-    return makeList(r.pOption);
-  },
-  pOption: function pOption(r) {
-    return P.seq(r.pIdentifier, BP.Equal, P.seq(P.alt(r.pIdentifier, r.pString).many(), P.alt(r.pOptionList, makeList(r.pIdentifier.many())).fallback(null))).desc('option');
-  },
-  pComparsionOp: function pComparsionOp() {
-    return P.regex(/IS|IS[^\S\r\n]+NOT|=|<>|!=|>|>=|!>|<|<=|!</i).skip(wss).desc('comparsion operator');
-  },
-  // SQL SERVER do not support boolean literal
-  pConst: function pConst(r) {
-    return P.alt(r.pString, r.pUnicode, r.pBinary, r.pScience, r.pMoney, r.pSigned, r.pNumber).desc('constant');
-  },
-  pFunction: function pFunction(r) {
-    return P.seq(r.pIdentifier, makeList(r.pFunctionParam, true)).map(function (value) {
-      return "".concat(value[0], "(").concat(value[1].join(','), ")");
-    }).thru(streamline('function')).desc('function constant');
-  },
-  pFunctionParam: function pFunctionParam(r) {
-    return P.alt(r.pNumber, r.pIdentifier).desc('identifier or number paremeter');
-  },
-  pMoney: function pMoney(r) {
-    return P.seq(P.regexp(/[+-]\$/), r.pNumber).thru(streamline('money')).desc('money constant');
-  },
-  pSigned: function pSigned(r) {
-    return P.seq(P.regexp(/[+-]/), r.pNumber).thru(streamline('signed')).desc('signed constant');
-  },
-  pUnicode: function pUnicode(r) {
-    return P.seq(P.string('N'), r.pString).thru(streamline('unicode')).desc('unicode constant');
-  },
-  pString: function pString() {
-    return P.regexp(/'[^']*'/).thru(streamline('string')).map(function (value) {
-      var stringLiteral = value.value;
-      value.value = stringLiteral.slice(1, stringLiteral.length - 1);
-      return value;
-    }).desc('string constant');
-  },
-  pNumberList: function pNumberList(r) {
-    return makeList(r.pNumber).desc('list of number');
-  },
-  pNumber: function pNumber() {
-    return P.regexp(/[0-9]+(\.[0-9]+)?/).map(Number).thru(streamline('number')).desc('number constant');
-  },
-  pBinary: function pBinary() {
-    return P.regexp(/0x[A-F0-9]*/).thru(streamline('binary')).desc('binary constant');
-  },
-  pScience: function pScience() {
-    return P.regexp(/[+-]+[0-9]+(\.[0-9E]+)?/).thru(streamline('science')).desc('science constant');
-  },
-  pIdentifier: function pIdentifier(r) {
-    return P.alt(r.pRegularIdentifier, r.pDelimitedIdentifier).skip(wss).desc('identifier');
-  },
-  pDelimitedIdentifier: function pDelimitedIdentifier(r) {
-    return P.alt(r.pDQDelimitedIdentifier, r.pBracketDelimitedIdentifier).skip(wss).desc('delimited identifier');
-  },
-  pRegularIdentifier: function pRegularIdentifier() {
-    return P.regexp(/^[\w@#][\w@#$]*/).skip(wss);
-  },
-  pDQDelimitedIdentifier: function pDQDelimitedIdentifier() {
-    return P.seq(P.string('"'), P.regexp(/[^"]*/), P.string('"')).map(function (value) {
-      return value[1];
-    }).skip(wss);
-  },
-  pBracketDelimitedIdentifier: function pBracketDelimitedIdentifier() {
-    return P.seq(P.string('['), P.regexp(/[^\]]*/), P.string(']')).map(function (value) {
-      return value[1];
-    }).skip(wss);
-  },
-  pKeywordPKOrUnique: function pKeywordPKOrUnique() {
-    return P.alt(BP.KeywordPrimaryKey.result({
-      type: 'pk',
-      value: true
-    }), BP.KeywordUnique.result({
-      type: 'unique',
-      value: true
-    }));
-  },
-  pKeywordClusteredOrNon: function pKeywordClusteredOrNon() {
-    return P.alt(BP.KeywordClustered, BP.KeywordNonclustered);
-  },
-  pKeywordAscOrDesc: function pKeywordAscOrDesc() {
-    return P.alt(BP.KeywordAsc, BP.KeywordDesc);
-  }
-});
-module.exports = Lang;

package/lib/parse/mssql/statement_types/alter_table/actions.js

@@ -1,29 +0,0 @@
-"use strict";
-
-var _ = require('lodash');
-
-function handleRef(tableName, result) {
-  var endpointWithNoTableName = result.value.endpoints.find(function (ele) {
-    return !ele.tableName;
-  });
-  endpointWithNoTableName.tableName = _.last(tableName);
-}
-
-function handleAlterTableResult(_keyword, tableName, result) {
-  if (!result) return null;
-
-  switch (result.type) {
-    case 'refs':
-      handleRef(tableName, result);
-      break;
-
-    default:
-      break;
-  }
-
-  return result;
-}
-
-module.exports = {
-  handleAlterTableResult: handleAlterTableResult
-};

package/lib/parse/mssql/statement_types/alter_table/add/actions.js

@@ -1,8 +0,0 @@
-"use strict";
-
-var _require = require('../../../constraint_definition'),
-    makeTableConstraint = _require.makeTableConstraint;
-
-module.exports = {
-  makeTableConstraint: makeTableConstraint
-};

package/lib/parse/mssql/statement_types/alter_table/add/index.js

@@ -1,58 +0,0 @@
-"use strict";
-
-var P = require('parsimmon');
-
-var BP = require('../../../base_parsers');
-
-var _require = require('../../../composite_parsers'),
-    pIdentifier = _require.pIdentifier;
-
-var _require2 = require('../../../utils'),
-    makeNode = _require2.makeNode,
-    makeList = _require2.makeList;
-
-var A = require('./actions');
-
-var _require3 = require('../../../fk_definition'),
-    pTableConstraintFK = _require3.pTableConstraintFK;
-
-var _require4 = require('../../../index_definition'),
-    pTableConstraintIndex = _require4.pTableConstraintIndex;
-
-var _require5 = require('../../../constraint_definition'),
-    pConstraintCheck = _require5.pConstraintCheck,
-    pConstExpr = _require5.pConstExpr,
-    pConstraintName = _require5.pConstraintName;
-
-var _require6 = require('../../../column_definition'),
-    pColumnsDefinition = _require6.pColumnsDefinition;
-
-var Lang = P.createLanguage({
-  AddAction: function AddAction(r) {
-    return P.seq(BP.KeywordAdd, r.AddOption).map(function (value) {
-      return value[1];
-    });
-  },
-  AddOption: function AddOption(r) {
-    return P.alt(r.AddConstraint, pColumnsDefinition.result(null), r.IgnoredAddSystemTimeOption.result(null));
-  },
-  IgnoredAddSystemTimeOption: function IgnoredAddSystemTimeOption() {
-    return P.alt(pIdentifier, P.regexp(/[(),]/)).many();
-  },
-  AddConstraint: function AddConstraint(r) {
-    return P.seqMap(pConstraintName.fallback(null), r.AddConstraintOption, A.makeTableConstraint).thru(makeNode());
-  },
-  AddConstraintOption: function AddConstraintOption(r) {
-    return P.alt(pTableConstraintFK, r.IgnoredAddConstraintOption);
-  },
-  IgnoredAddConstraintOption: function IgnoredAddConstraintOption(r) {
-    return P.alt(pTableConstraintIndex, pConstraintCheck, r.AddConstraintDefault, r.AddConstraintConnection);
-  },
-  AddConstraintDefault: function AddConstraintDefault() {
-    return P.seq(BP.KeywordDefault, pConstExpr, BP.KeywordFor, pIdentifier, BP.KeywordWithValues.fallback(null));
-  },
-  AddConstraintConnection: function AddConstraintConnection() {
-    return P.seq(BP.KeywordConnection, makeList(P.seq(pIdentifier, BP.KeywordTo, pIdentifier)));
-  }
-});
-module.exports = Lang.AddAction;

package/lib/parse/mssql/statement_types/alter_table/index.js

@@ -1,32 +0,0 @@
-"use strict";
-
-var P = require('parsimmon');
-
-var BP = require('../../base_parsers');
-
-var _require = require('../../composite_parsers'),
-    pDotDelimitedName = _require.pDotDelimitedName,
-    pIgnore = _require.pIgnore;
-
-var A = require('./actions');
-
-var pAddAction = require('./add');
-
-var Lang = P.createLanguage({
-  AlterTable: function AlterTable(r) {
-    return P.seqMap(r.AlterTableKeywords, pDotDelimitedName, r.AlterTableActions, A.handleAlterTableResult);
-  },
-  AlterTableActions: function AlterTableActions(r) {
-    return P.alt(pAddAction, r.IgnoredAlterTableActions);
-  },
-  AlterTableKeywords: function AlterTableKeywords() {
-    return P.seq(BP.KeywordAlter, BP.KeywordTable);
-  },
-  IgnoredAlterTableActions: function IgnoredAlterTableActions(r) {
-    return P.seq(r.IgnoredAlterTableActionKeywords, pIgnore).result(null);
-  },
-  IgnoredAlterTableActionKeywords: function IgnoredAlterTableActionKeywords() {
-    return P.alt(BP.KeywordWith, BP.KeywordAlterColumn, BP.KeywordDrop, BP.KeywordEnable, BP.KeywordDisable, BP.KeywordCheck, BP.KeywordSwitch, BP.KeywordSet, BP.KeywordRebuild);
-  }
-});
-module.exports = Lang.AlterTable;

package/lib/parse/mssql/statement_types/create_index/actions.js

@@ -1,25 +0,0 @@
-"use strict";
-
-function makeIndex(_create, isUnique, _clustered, _index, indexName, _on, tableName, columnNames) {
-  var columns = [];
-  columnNames.forEach(function (columnName) {
-    columns.push({
-      value: columnName,
-      type: 'column'
-    });
-  });
-  return {
-    type: 'indexes',
-    value: {
-      name: indexName,
-      type: 'btree',
-      unique: isUnique ? true : null,
-      tableName: tableName[tableName.length - 1],
-      columns: columns
-    }
-  };
-}
-
-module.exports = {
-  makeIndex: makeIndex
-};

package/lib/parse/mssql/statement_types/create_index/index.js

@@ -1,50 +0,0 @@
-"use strict";
-
-var P = require('parsimmon');
-
-var BP = require('../../base_parsers');
-
-var _require = require('../../composite_parsers'),
-    pIdentifier = _require.pIdentifier,
-    pKeywordClusteredOrNon = _require.pKeywordClusteredOrNon,
-    pConst = _require.pConst,
-    pColumnNames = _require.pColumnNames,
-    pDotDelimitedName = _require.pDotDelimitedName,
-    pComparsionOp = _require.pComparsionOp;
-
-var _require2 = require('../../utils'),
-    makeNode = _require2.makeNode,
-    makeList = _require2.makeList;
-
-var A = require('./actions');
-
-var _require3 = require('../../index_definition'),
-    pIgnoredIndexOption = _require3.pIgnoredIndexOption;
-
-var Lang = P.createLanguage({
-  CreateIndex: function CreateIndex(r) {
-    return P.seqMap(BP.KeywordCreate, BP.KeywordUnique.fallback(null), pKeywordClusteredOrNon.fallback(null), BP.KeywordIndex, pIdentifier, BP.KeywordOn, pDotDelimitedName, pColumnNames, A.makeIndex).thru(makeNode()).skip(r.IgnoredCreateIndexOptions);
-  },
-  IgnoredCreateIndexOptions: function IgnoredCreateIndexOptions(r) {
-    return P.alt(pIgnoredIndexOption, r.IncludeIndexOption, r.WhereIndexOption).many();
-  },
-  IncludeIndexOption: function IncludeIndexOption() {
-    return P.seq(BP.KeywordInclude, pColumnNames);
-  },
-  WhereIndexOption: function WhereIndexOption(r) {
-    return P.seq(BP.KeywordWhere, r.FilterPredicate);
-  },
-  FilterPredicate: function FilterPredicate(r) {
-    return P.seq(r.Conjunct, P.seq(BP.LogicalOpAnd, r.Conjunct).fallback(null));
-  },
-  Conjunct: function Conjunct(r) {
-    return P.alt(r.Disjunct, r.Comparsion);
-  },
-  Disjunct: function Disjunct() {
-    return P.seq(pIdentifier, BP.KeywordIn, makeList(pConst));
-  },
-  Comparsion: function Comparsion() {
-    return P.seq(pIdentifier, pComparsionOp, pConst);
-  }
-});
-module.exports = Lang.CreateIndex;

package/lib/parse/mssql/statement_types/create_table/actions.js

@@ -1,95 +0,0 @@
-"use strict";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var _ = require('lodash');
-
-function createRefFromInlineRef(linesRefs, inlineRefs, fieldName, tableName) {
-  if (!inlineRefs || inlineRefs.length === 0) return;
-  var newRef = {};
-  var inlineRef = inlineRefs[0];
-  newRef.onUpdate = inlineRef.onUpdate;
-  newRef.onDelete = inlineRef.onDelete;
-  newRef.endpoints = [];
-  newRef.endpoints.push({
-    tableName: tableName,
-    fieldNames: [fieldName],
-    relation: '*'
-  });
-  newRef.endpoints.push(inlineRef.endpoint);
-  linesRefs.push(newRef);
-}
-
-function pushOutEnum(linesEnums, fieldValue, tableName) {
-  if (fieldValue.enums) {
-    var _enum = fieldValue.enums;
-    var fieldType = fieldValue.type;
-    _enum.name = "".concat(tableName, "_").concat(fieldValue.enums.name);
-    fieldType.type_name = _enum.name;
-    fieldType.args = _enum.values.map(function (value) {
-      return "'".concat(value.name, "'");
-    }).join(', ');
-    linesEnums.push(_enum);
-    fieldValue.enums = null;
-  }
-}
-
-function pushOutIndex(linesIndexes, fieldValue) {
-  if (fieldValue.indexes) {
-    fieldValue.indexes.columns.push({
-      value: fieldValue.name,
-      type: 'column'
-    });
-    linesIndexes.push(fieldValue.indexes);
-    fieldValue.indexes = null;
-  }
-}
-
-function getLinesValue(lines, tableName) {
-  var value = {
-    fields: [],
-    enums: [],
-    refs: [],
-    indexes: []
-  };
-  lines.forEach(function (line) {
-    if (line && value[line.type]) {
-      if (line.type === 'fields') {
-        pushOutEnum(value.enums, line.value, tableName);
-        pushOutIndex(value.indexes, line.value);
-        createRefFromInlineRef(value.refs, line.value.inline_refs, line.value.name, tableName);
-      }
-
-      if (line.type === 'refs') {
-        var ref = line.value;
-        ref.endpoints[0].tableName = tableName;
-      }
-
-      value[line.type].push(line.value);
-    }
-  });
-  return {
-    type: 'lines',
-    value: value
-  };
-}
-
-function makeTable(_keyword, tableName, _keyword2, lines) {
-  var linesValue = getLinesValue(lines, _.last(tableName));
-  return {
-    type: 'tables',
-    value: _objectSpread({
-      name: _.last(tableName)
-    }, linesValue.value, {
-      schemaName: tableName.length > 1 ? tableName[tableName.length - 2] : null
-    })
-  };
-}
-
-module.exports = {
-  makeTable: makeTable
-};

package/lib/parse/mssql/statement_types/create_table/index.js

@@ -1,50 +0,0 @@
-"use strict";
-
-var P = require('parsimmon');
-
-var BP = require('../../base_parsers');
-
-var _require = require('../../composite_parsers'),
-    pIdentifier = _require.pIdentifier,
-    pDotDelimitedName = _require.pDotDelimitedName;
-
-var _require2 = require('../../utils'),
-    makeNode = _require2.makeNode,
-    makeList = _require2.makeList;
-
-var _require3 = require('../../constraint_definition'),
-    pTableConstraint = _require3.pTableConstraint;
-
-var _require4 = require('../../index_definition'),
-    pTableIndex = _require4.pTableIndex,
-    pIgnoredIndexOption = _require4.pIgnoredIndexOption;
-
-var _require5 = require('../../column_definition'),
-    pColumnsDefinition = _require5.pColumnsDefinition;
-
-var A = require('./actions');
-
-var Lang = P.createLanguage({
-  CreateTable: function CreateTable(r) {
-    return P.seqMap(r.CreateTableKeywords, pDotDelimitedName, r.AsFileTableKeywords.fallback(null), makeList(r.Line), A.makeTable).thru(makeNode()).skip(r.IgnoredTableOptions);
-  },
-  CreateTableKeywords: function CreateTableKeywords() {
-    return P.seq(BP.KeywordCreate, BP.KeywordTable);
-  },
-  AsFileTableKeywords: function AsFileTableKeywords() {
-    return P.seq(BP.KeywordAs, BP.KeywordFileTable);
-  },
-  Line: function Line(r) {
-    return P.alt(r.SystemTimeTableOption, pTableConstraint, pTableIndex, pColumnsDefinition);
-  },
-  SystemTimeTableOption: function SystemTimeTableOption() {
-    return P.seq(BP.KeywordPeriodForST, makeList(pIdentifier)).result(null);
-  },
-  IgnoredTableOptions: function IgnoredTableOptions(r) {
-    return P.alt(pIgnoredIndexOption, r.TextImageTableOption).many();
-  },
-  TextImageTableOption: function TextImageTableOption() {
-    return P.seq(BP.KeywordTextImage_On, pIdentifier);
-  }
-});
-module.exports = Lang.CreateTable;

package/lib/parse/mssql/statement_types/index.js

@@ -1,13 +0,0 @@
-"use strict";
-
-var pAlterTable = require('./alter_table');
-
-var pCreateIndex = require('./create_index/index');
-
-var pCreateTable = require('./create_table');
-
-module.exports = {
-  pAlterTable: pAlterTable,
-  pCreateIndex: pCreateIndex,
-  pCreateTable: pCreateTable
-};

package/lib/schema/element.js

@@ -1,84 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
-
-function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
-
-function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
-
-function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-var ElementError =
-/*#__PURE__*/
-function (_Error) {
-  _inherits(ElementError, _Error);
-
-  function ElementError(message) {
-    var _this;
-
-    var location = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      start: {
-        line: 1,
-        column: 1
-      }
-    };
-
-    _classCallCheck(this, ElementError);
-
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(ElementError).call(this, message));
-    _this.location = location;
-    return _this;
-  }
-
-  return ElementError;
-}(_wrapNativeSuper(Error));
-
-var Element =
-/*#__PURE__*/
-function () {
-  function Element(token) {
-    _classCallCheck(this, Element);
-
-    this.token = token;
-  }
-
-  _createClass(Element, [{
-    key: "bind",
-    value: function bind(selection) {
-      this.selection = selection;
-    }
-  }, {
-    key: "error",
-    value: function error(message) {
-      throw new ElementError(message, this.token);
-    }
-  }]);
-
-  return Element;
-}();
-
-var _default = Element;
-exports["default"] = _default;