@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/@ungap/structured-clone/esm/serialize.js

@@ -0,0 +1,171 @@
+import {
+  VOID, PRIMITIVE,
+  ARRAY, OBJECT,
+  DATE, REGEXP, MAP, SET,
+  ERROR, BIGINT
+} from './types.js';
+
+const EMPTY = '';
+
+const {toString} = {};
+const {keys} = Object;
+
+const typeOf = value => {
+  const type = typeof value;
+  if (type !== 'object' || !value)
+    return [PRIMITIVE, type];
+
+  const asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case 'Array':
+      return [ARRAY, EMPTY];
+    case 'Object':
+      return [OBJECT, EMPTY];
+    case 'Date':
+      return [DATE, EMPTY];
+    case 'RegExp':
+      return [REGEXP, EMPTY];
+    case 'Map':
+      return [MAP, EMPTY];
+    case 'Set':
+      return [SET, EMPTY];
+    case 'DataView':
+      return [ARRAY, asString];
+  }
+
+  if (asString.includes('Array'))
+    return [ARRAY, asString];
+
+  if (asString.includes('Error'))
+    return [ERROR, asString];
+
+  return [OBJECT, asString];
+};
+
+const shouldSkip = ([TYPE, type]) => (
+  TYPE === PRIMITIVE &&
+  (type === 'function' || type === 'symbol')
+);
+
+const serializer = (strict, json, $, _) => {
+
+  const as = (out, value) => {
+    const index = _.push(out) - 1;
+    $.set(value, index);
+    return index;
+  };
+
+  const pair = value => {
+    if ($.has(value))
+      return $.get(value);
+
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case PRIMITIVE: {
+        let entry = value;
+        switch (type) {
+          case 'bigint':
+            TYPE = BIGINT;
+            entry = value.toString();
+            break;
+          case 'function':
+          case 'symbol':
+            if (strict)
+              throw new TypeError('unable to serialize ' + type);
+            entry = null;
+            break;
+          case 'undefined':
+            return as([VOID], value);
+        }
+        return as([TYPE, entry], value);
+      }
+      case ARRAY: {
+        if (type) {
+          let spread = value;
+          if (type === 'DataView') {
+            spread = new Uint8Array(value.buffer);
+          }
+          else if (type === 'ArrayBuffer') {
+            spread = new Uint8Array(value);
+          }
+          return as([type, [...spread]], value);
+        }
+
+        const arr = [];
+        const index = as([TYPE, arr], value);
+        for (const entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case OBJECT: {
+        if (type) {
+          switch (type) {
+            case 'BigInt':
+              return as([type, value.toString()], value);
+            case 'Boolean':
+            case 'Number':
+            case 'String':
+              return as([type, value.valueOf()], value);
+          }
+        }
+
+        if (json && ('toJSON' in value))
+          return pair(value.toJSON());
+
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const key of keys(value)) {
+          if (strict || !shouldSkip(typeOf(value[key])))
+            entries.push([pair(key), pair(value[key])]);
+        }
+        return index;
+      }
+      case DATE:
+        return as([TYPE, isNaN(value.getTime()) ? EMPTY : value.toISOString()], value);
+      case REGEXP: {
+        const {source, flags} = value;
+        return as([TYPE, {source, flags}], value);
+      }
+      case MAP: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const [key, entry] of value) {
+          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+            entries.push([pair(key), pair(entry)]);
+        }
+        return index;
+      }
+      case SET: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const entry of value) {
+          if (strict || !shouldSkip(typeOf(entry)))
+            entries.push(pair(entry));
+        }
+        return index;
+      }
+    }
+
+    const {message} = value;
+    return as([TYPE, {name: type, message}], value);
+  };
+
+  return pair;
+};
+
+/**
+ * @typedef {Array<string,any>} Record a type representation
+ */
+
+/**
+ * Returns an array of serialized Records.
+ * @param {any} value a serializable value.
+ * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,
+ *  if `true`, will not throw errors on incompatible types, and behave more
+ *  like JSON stringify would behave. Symbol and Function will be discarded.
+ * @returns {Record[]}
+ */
+ export const serialize = (value, {json, lossy} = {}) => {
+  const _ = [];
+  return serializer(!(json || lossy), !!json, new Map, _)(value), _;
+};

package/etc/mcp-server/node_modules/@ungap/structured-clone/esm/types.js

@@ -0,0 +1,11 @@
+export const VOID       = -1;
+export const PRIMITIVE  = 0;
+export const ARRAY      = 1;
+export const OBJECT     = 2;
+export const DATE       = 3;
+export const REGEXP     = 4;
+export const MAP        = 5;
+export const SET        = 6;
+export const ERROR      = 7;
+export const BIGINT     = 8;
+// export const SYMBOL = 9;

package/etc/mcp-server/node_modules/@ungap/structured-clone/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@ungap/structured-clone",
+  "version": "1.3.2",
+  "description": "A structuredClone polyfill",
+  "main": "./cjs/index.js",
+  "scripts": {
+    "build": "npm run cjs && npm run rollup:json && npm run test",
+    "cjs": "ascjs esm cjs",
+    "coverage": "c8 report --reporter=text-lcov > ./coverage/lcov.info",
+    "rollup:json": "rollup --config rollup/json.config.js",
+    "test": "c8 node test/index.js"
+  },
+  "keywords": [
+    "recursion",
+    "structured",
+    "clone",
+    "algorithm"
+  ],
+  "author": "Andrea Giammarchi",
+  "license": "ISC",
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "ascjs": "^6.0.3",
+    "c8": "^11.0.0",
+    "coveralls": "^3.1.1",
+    "rollup": "^4.62.2"
+  },
+  "overrides": {
+    "c8": {
+      "yargs": "^18.0.0"
+    }
+  },
+  "module": "./esm/index.js",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "default": "./cjs/index.js"
+    },
+    "./json": {
+      "import": "./esm/json.js",
+      "default": "./cjs/json.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ungap/structured-clone.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ungap/structured-clone/issues"
+  },
+  "homepage": "https://github.com/ungap/structured-clone#readme"
+}

package/etc/mcp-server/node_modules/@ungap/structured-clone/structured-json.js

@@ -0,0 +1 @@
+var StructuredJSON=function(e){"use strict";const r="object"==typeof self?self:globalThis,t=(e,t)=>{switch(e){case"Function":case"SharedWorker":case"Worker":case"eval":case"setInterval":case"setTimeout":throw new TypeError("unable to deserialize "+e)}return new r[e](t)},s=e=>((e,r)=>{const s=(r,t)=>(e.set(t,r),r),n=c=>{if(e.has(c))return e.get(c);const[a,o]=r[c];switch(a){case 0:case-1:return s(o,c);case 1:{const e=s([],c);for(const r of o)e.push(n(r));return e}case 2:{const e=s({},c);for(const[r,t]of o)e[n(r)]=n(t);return e}case 3:return s(new Date(o),c);case 4:{const{source:e,flags:r}=o;return s(new RegExp(e,r),c)}case 5:{const e=s(new Map,c);for(const[r,t]of o)e.set(n(r),n(t));return e}case 6:{const e=s(new Set,c);for(const r of o)e.add(n(r));return e}case 7:{const{name:e,message:r}=o;return s(t(e,r),c)}case 8:return s(BigInt(o),c);case"BigInt":return s(Object(BigInt(o)),c);case"ArrayBuffer":return s(new Uint8Array(o).buffer,o);case"DataView":{const{buffer:e}=new Uint8Array(o);return s(new DataView(e),o)}}return s(t(a,o),c)};return n})(new Map,e)(0),n="",{toString:c}={},{keys:a}=Object,o=e=>{const r=typeof e;if("object"!==r||!e)return[0,r];const t=c.call(e).slice(8,-1);switch(t){case"Array":return[1,n];case"Object":return[2,n];case"Date":return[3,n];case"RegExp":return[4,n];case"Map":return[5,n];case"Set":return[6,n];case"DataView":return[1,t]}return t.includes("Array")?[1,t]:t.includes("Error")?[7,t]:[2,t]},u=([e,r])=>0===e&&("function"===r||"symbol"===r),i=(e,{json:r,lossy:t}={})=>{const s=[];return((e,r,t,s)=>{const c=(e,r)=>{const n=s.push(e)-1;return t.set(r,n),n},i=s=>{if(t.has(s))return t.get(s);let[f,l]=o(s);switch(f){case 0:{let r=s;switch(l){case"bigint":f=8,r=s.toString();break;case"function":case"symbol":if(e)throw new TypeError("unable to serialize "+l);r=null;break;case"undefined":return c([-1],s)}return c([f,r],s)}case 1:{if(l){let e=s;return"DataView"===l?e=new Uint8Array(s.buffer):"ArrayBuffer"===l&&(e=new Uint8Array(s)),c([l,[...e]],s)}const e=[],r=c([f,e],s);for(const r of s)e.push(i(r));return r}case 2:{if(l)switch(l){case"BigInt":return c([l,s.toString()],s);case"Boolean":case"Number":case"String":return c([l,s.valueOf()],s)}if(r&&"toJSON"in s)return i(s.toJSON());const t=[],n=c([f,t],s);for(const r of a(s))!e&&u(o(s[r]))||t.push([i(r),i(s[r])]);return n}case 3:return c([f,isNaN(s.getTime())?n:s.toISOString()],s);case 4:{const{source:e,flags:r}=s;return c([f,{source:e,flags:r}],s)}case 5:{const r=[],t=c([f,r],s);for(const[t,n]of s)(e||!u(o(t))&&!u(o(n)))&&r.push([i(t),i(n)]);return t}case 6:{const r=[],t=c([f,r],s);for(const t of s)!e&&u(o(t))||r.push(i(t));return t}}const{message:w}=s;return c([f,{name:l,message:w}],s)};return i})(!(r||t),!!r,new Map,s)(e),s},{parse:f,stringify:l}=JSON,w={json:!0,lossy:!0};return e.parse=e=>s(f(e)),e.stringify=e=>l(i(e,w)),e}({});

package/etc/mcp-server/node_modules/@vitest/mocker/node_modules/.bin/vite

@@ -6,12 +6,12 @@ case `uname` in
 esac
 
 if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/vite@6.4.3_@types+node@22.19.19/node_modules/vite/bin/node_modules:/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/vite@6.4.3_@types+node@22.19.19/node_modules/vite/node_modules:/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/vite@6.4.3_@types+node@22.19.19/node_modules:/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/node_modules"
+  export NODE_PATH="/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/vite@6.4.3_@types+node@20.14.10/node_modules/vite/bin/node_modules:/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/vite@6.4.3_@types+node@20.14.10/node_modules/vite/node_modules:/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/vite@6.4.3_@types+node@20.14.10/node_modules:/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/node_modules"
 else
-  export NODE_PATH="/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/vite@6.4.3_@types+node@22.19.19/node_modules/vite/bin/node_modules:/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/vite@6.4.3_@types+node@22.19.19/node_modules/vite/node_modules:/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/vite@6.4.3_@types+node@22.19.19/node_modules:/Users/baraklagziel/code/venos/.worktrees/publish-cli-0.1.14/node_modules/.pnpm/node_modules:$NODE_PATH"
+  export NODE_PATH="/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/vite@6.4.3_@types+node@20.14.10/node_modules/vite/bin/node_modules:/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/vite@6.4.3_@types+node@20.14.10/node_modules/vite/node_modules:/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/vite@6.4.3_@types+node@20.14.10/node_modules:/Users/baraklagziel/code/venos/.worktrees/cli-publish-0115/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../../../../../../vite@6.4.3_@types+node@22.19.19/node_modules/vite/bin/vite.js" "$@"
+  exec "$basedir/node"  "$basedir/../../../../../../vite@6.4.3_@types+node@20.14.10/node_modules/vite/bin/vite.js" "$@"
 else
-  exec node  "$basedir/../../../../../../vite@6.4.3_@types+node@22.19.19/node_modules/vite/bin/vite.js" "$@"
+  exec node  "$basedir/../../../../../../vite@6.4.3_@types+node@20.14.10/node_modules/vite/bin/vite.js" "$@"
 fi

package/etc/mcp-server/node_modules/acorn-import-attributes/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Sven Sauleau
+
+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.

package/etc/mcp-server/node_modules/acorn-import-attributes/README.md

@@ -0,0 +1,21 @@
+# Support for import attributes in acorn
+
+## Install
+
+```
+yarn add acorn-import-attributes
+```
+
+## Usage
+
+This module provides a plugin that can be used to extend the Acorn Parser class:
+
+```js
+const {Parser} = require('acorn');
+const {importAttributes} = require('acorn-import-attributes');
+Parser.extend(importAttributes).parse('...');
+```
+
+## License
+
+This plugin is released under an MIT License.

package/etc/mcp-server/node_modules/acorn-import-attributes/lib/index.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.importAttributesOrAssertions = exports.importAttributes = exports.importAssertions = void 0;
+var _acorn = _interopRequireWildcard(require("acorn"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const leftCurlyBrace = "{".charCodeAt(0);
+const space = " ".charCodeAt(0);
+const withKeyword = "with";
+const assertKeyword = "assert";
+const FUNC_STATEMENT = 1,
+  FUNC_HANGING_STATEMENT = 2,
+  FUNC_NULLABLE_ID = 4;
+const importAttributes = exports.importAttributes = plugin({
+  keyword: "with"
+});
+const importAssertions = exports.importAssertions = plugin({
+  keyword: "assert"
+});
+const importAttributesOrAssertions = exports.importAttributesOrAssertions = plugin({
+  keyword: "with-assert"
+});
+function plugin(options) {
+  return function (Parser) {
+    return pluginImpl(options, Parser);
+  };
+}
+function pluginImpl(options, Parser) {
+  // Use supplied version acorn version if present, to avoid
+  // reference mismatches due to different acorn versions. This
+  // allows this plugin to be used with Rollup which supplies
+  // its own internal version of acorn and thereby sidesteps
+  // the package manager.
+  const acorn = Parser.acorn || _acorn;
+  const {
+    tokTypes: tt,
+    TokenType
+  } = acorn;
+  const {
+    keyword
+  } = options;
+  const isWithKeyword = keyword.includes(withKeyword);
+  const isAssertKeyword = keyword.includes(assertKeyword);
+  const isWithOrAssertKeyword = isWithKeyword && isAssertKeyword;
+  return class extends Parser {
+    constructor(...args) {
+      super(...args);
+      this.withToken = isWithKeyword && new TokenType(withKeyword);
+      this.assertToken = isAssertKeyword && new TokenType(assertKeyword);
+    }
+    _codeAt(i) {
+      return this.input.charCodeAt(i);
+    }
+    _eat(t) {
+      if (this.type !== t) {
+        this.unexpected();
+      }
+      this.next();
+    }
+    _matchKeywordToken() {
+      return isWithOrAssertKeyword && (this.type === this.withToken || this.type === this.assertToken) || isWithKeyword && this.type === this.withToken || isAssertKeyword && this.type === this.assertToken;
+    }
+    _getProperty() {
+      if (isWithOrAssertKeyword) {
+        return this.type === this.withToken ? "attributes" : "assertions";
+      }
+      return isWithKeyword ? "attributes" : "assertions";
+    }
+    readToken(code) {
+      let i = 0;
+      let keyword;
+      let token;
+      if (isWithOrAssertKeyword) {
+        if (this.input.slice(this.pos, this.pos + withKeyword.length) === withKeyword) {
+          keyword = withKeyword;
+          token = this.withToken;
+        } else if (this.input.slice(this.pos, this.pos + assertKeyword.length) === assertKeyword) {
+          keyword = assertKeyword;
+          token = this.assertToken;
+        } else {
+          return super.readToken(code);
+        }
+        i += keyword.length;
+      } else {
+        keyword = isWithKeyword ? withKeyword : assertKeyword;
+        token = isWithKeyword ? this.withToken : this.assertToken;
+        for (; i < keyword.length; i++) {
+          if (this._codeAt(this.pos + i) !== keyword.charCodeAt(i)) {
+            return super.readToken(code);
+          }
+        }
+      }
+
+      // ensure that the keyword is at the correct location
+      // ie `with{...` or `with {...`
+      for (;; i++) {
+        if (this._codeAt(this.pos + i) === leftCurlyBrace) {
+          // Found '{'
+          break;
+        } else if (this._codeAt(this.pos + i) === space) {
+          // white space is allowed between `with` and `{`, so continue.
+          continue;
+        } else {
+          return super.readToken(code);
+        }
+      }
+
+      // If we're inside a dynamic import expression we'll parse
+      // the `with` keyword as a standard object property name
+      // ie `import(""./foo.json", { with: { type: "json" } })`
+      if (this.type.label === "{") {
+        return super.readToken(code);
+      }
+      this.pos += keyword.length;
+      return this.finishToken(token);
+    }
+    parseDynamicImport(node) {
+      this.next(); // skip `(`
+
+      // Parse node.source.
+      node.source = this.parseMaybeAssign();
+      if (this.eat(tt.comma)) {
+        const expr = this.parseExpression();
+        node.arguments = [expr];
+      }
+      this._eat(tt.parenR);
+      return this.finishNode(node, "ImportExpression");
+    }
+
+    // ported from acorn/src/statement.js pp.parseExport
+    parseExport(node, exports) {
+      this.next();
+      // export * from '...'
+      if (this.eat(tt.star)) {
+        if (this.options.ecmaVersion >= 11) {
+          if (this.eatContextual("as")) {
+            node.exported = this.parseIdent(true);
+            this.checkExport(exports, node.exported.name, this.lastTokStart);
+          } else {
+            node.exported = null;
+          }
+        }
+        this.expectContextual("from");
+        if (this.type !== tt.string) {
+          this.unexpected();
+        }
+        node.source = this.parseExprAtom();
+        if (this._matchKeywordToken()) {
+          const property = this._getProperty();
+          this.next();
+          const attributes = this.parseImportAttributes();
+          if (attributes) {
+            node[property] = attributes;
+          }
+        }
+        this.semicolon();
+        return this.finishNode(node, "ExportAllDeclaration");
+      }
+      if (this.eat(tt._default)) {
+        // export default ...
+        this.checkExport(exports, "default", this.lastTokStart);
+        var isAsync;
+        if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {
+          var fNode = this.startNode();
+          this.next();
+          if (isAsync) {
+            this.next();
+          }
+          node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+        } else if (this.type === tt._class) {
+          var cNode = this.startNode();
+          node.declaration = this.parseClass(cNode, "nullableID");
+        } else {
+          node.declaration = this.parseMaybeAssign();
+          this.semicolon();
+        }
+        return this.finishNode(node, "ExportDefaultDeclaration");
+      }
+      // export var|const|let|function|class ...
+      if (this.shouldParseExportStatement()) {
+        node.declaration = this.parseStatement(null);
+        if (node.declaration.type === "VariableDeclaration") {
+          this.checkVariableExport(exports, node.declaration.declarations);
+        } else {
+          this.checkExport(exports, node.declaration.id.name, node.declaration.id.start);
+        }
+        node.specifiers = [];
+        node.source = null;
+      } else {
+        // export { x, y as z } [from '...']
+        node.declaration = null;
+        node.specifiers = this.parseExportSpecifiers(exports);
+        if (this.eatContextual("from")) {
+          if (this.type !== tt.string) {
+            this.unexpected();
+          }
+          node.source = this.parseExprAtom();
+          if (this._matchKeywordToken()) {
+            const property = this._getProperty();
+            this.next();
+            const attributes = this.parseImportAttributes();
+            if (attributes) {
+              node[property] = attributes;
+            }
+          }
+        } else {
+          for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+            // check for keywords used as local names
+            var spec = list[i];
+            this.checkUnreserved(spec.local);
+            // check if export is defined
+            this.checkLocalExport(spec.local);
+          }
+          node.source = null;
+        }
+        this.semicolon();
+      }
+      return this.finishNode(node, "ExportNamedDeclaration");
+    }
+    parseImport(node) {
+      this.next();
+      // import '...'
+      if (this.type === tt.string) {
+        node.specifiers = [];
+        node.source = this.parseExprAtom();
+      } else {
+        node.specifiers = this.parseImportSpecifiers();
+        this.expectContextual("from");
+        node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+      }
+      if (this._matchKeywordToken()) {
+        const property = this._getProperty();
+        this.next();
+        const attributes = this.parseImportAttributes();
+        if (attributes) {
+          node[property] = attributes;
+        }
+      }
+      this.semicolon();
+      return this.finishNode(node, "ImportDeclaration");
+    }
+    parseImportAttributes() {
+      this._eat(tt.braceL);
+      const attrs = this.parsewithEntries();
+      this._eat(tt.braceR);
+      return attrs;
+    }
+    parsewithEntries() {
+      const attrs = [];
+      const attrNames = new Set();
+      do {
+        if (this.type === tt.braceR) {
+          break;
+        }
+        const node = this.startNode();
+
+        // parse withionKey : IdentifierName, StringLiteral
+        let withionKeyNode;
+        if (this.type === tt.string) {
+          withionKeyNode = this.parseLiteral(this.value);
+        } else {
+          withionKeyNode = this.parseIdent(true);
+        }
+        this.next();
+        node.key = withionKeyNode;
+
+        // check if we already have an entry for an attribute
+        // if a duplicate entry is found, throw an error
+        // for now this logic will come into play only when someone declares `type` twice
+        if (attrNames.has(node.key.name)) {
+          this.raise(this.pos, "Duplicated key in attributes");
+        }
+        attrNames.add(node.key.name);
+        if (this.type !== tt.string) {
+          this.raise(this.pos, "Only string is supported as an attribute value");
+        }
+        node.value = this.parseLiteral(this.value);
+        attrs.push(this.finishNode(node, "ImportAttribute"));
+      } while (this.eat(tt.comma));
+      return attrs;
+    }
+  };
+}