code-the-jewels 0.1.0

package/dist/repl.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRepl = startRepl;
+const readline = __importStar(require("readline"));
+const path = __importStar(require("path"));
+const vm = __importStar(require("vm"));
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const semantic_1 = require("./semantic");
+const generator_1 = require("./generator");
+const diagnostics_1 = require("./diagnostics");
+function startRepl() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: 'rtj> ',
+    });
+    // Load the runtime once
+    const runtimePath = path.join(__dirname, 'runtime', 'rtj-core');
+    const rtjCore = require(runtimePath);
+    // Persistent context for the REPL
+    const context = vm.createContext({
+        __rtj: rtjCore,
+        __modules: rtjCore.modules,
+        console: console,
+        require: require,
+    });
+    const history = [];
+    console.log('');
+    console.log('  \uD83D\uDC49{\uD83D\uDC8E}.rtj');
+    console.log('  Code The Jewels v0.1 \u2014 RTJ0 "The Self-Titled Era"');
+    console.log('  El-P (Brooklyn) & Killer Mike (Atlanta) \u2014 MIT Forever');
+    console.log('');
+    console.log('  .help for commands  \u00B7  .exit to quit');
+    console.log('');
+    rl.prompt();
+    rl.on('line', (line) => {
+        const input = line.trim();
+        if (input === '.exit') {
+            process.exit(0);
+        }
+        if (input === '') {
+            rl.prompt();
+            return;
+        }
+        if (input === '.help') {
+            console.log('.exit   quit the REPL');
+            console.log('.legend print version info');
+            console.log('.duo    print duo() spec');
+            rl.prompt();
+            return;
+        }
+        if (input === '.legend') {
+            console.log('Code The Jewels v0.1 \u2014 RTJ0 "The Self-Titled Era"');
+            console.log('El-P (Brooklyn) & Killer Mike (Atlanta) \u2014 MIT Forever');
+            rl.prompt();
+            return;
+        }
+        if (input === '.duo') {
+            console.log('duo(input) { mike: fn  el: fn }');
+            console.log('mike runs first (Atlanta). el responds (Brooklyn).');
+            console.log('Both branches required. Compiles to: el(mike(input))');
+            rl.prompt();
+            return;
+        }
+        try {
+            const lexer = new lexer_1.Lexer(input);
+            const tokens = lexer.tokenize();
+            const parser = new parser_1.Parser(tokens);
+            const ast = parser.parse();
+            const semantic = new semantic_1.Semantic();
+            semantic.analyze(ast);
+            const gen = new generator_1.Generator();
+            let js = gen.generate(ast);
+            // Strip the prelude since we already have the runtime in context
+            js = js.replace('"use strict";\n', '');
+            js = js.replace('const __rtj = require("./runtime/rtj-core");\n', '');
+            js = js.replace('const __modules = __rtj.modules;\n', '');
+            history.push(js);
+            const result = vm.runInContext(js, context);
+            if (result !== undefined) {
+                console.log(result);
+            }
+        }
+        catch (err) {
+            if (err instanceof diagnostics_1.RTJError) {
+                console.error(err.format());
+            }
+            else if (err instanceof Error) {
+                console.error(err.message);
+            }
+            else {
+                console.error(err);
+            }
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => process.exit(0));
+}

package/dist/runtime/atl-data.d.ts

@@ -0,0 +1,4 @@
+export declare const count: (list: unknown[]) => number;
+export declare const countBy: (list: unknown[]) => Record<string, number>;
+export declare const first: (list: unknown[]) => unknown;
+export declare const last: (list: unknown[]) => unknown;

package/dist/runtime/atl-data.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.last = exports.first = exports.countBy = exports.count = void 0;
+const count = (list) => list.length;
+exports.count = count;
+const countBy = (list) => {
+    const map = {};
+    for (const item of list) {
+        const key = String(item);
+        map[key] = (map[key] || 0) + 1;
+    }
+    return map;
+};
+exports.countBy = countBy;
+const first = (list) => list[0];
+exports.first = first;
+const last = (list) => list[list.length - 1];
+exports.last = last;

package/dist/runtime/atl-flow.d.ts

@@ -0,0 +1 @@
+export declare const identity: (x: unknown) => unknown;

package/dist/runtime/atl-flow.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identity = void 0;
+const identity = (x) => x;
+exports.identity = identity;

package/dist/runtime/bk-parse.d.ts

@@ -0,0 +1,3 @@
+export declare const words: (text: string) => string[];
+export declare const lines: (text: string) => string[];
+export declare const chars: (text: string) => string[];

package/dist/runtime/bk-parse.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chars = exports.lines = exports.words = void 0;
+const words = (text) => text.trim().split(/\s+/).filter(w => w.length > 0);
+exports.words = words;
+const lines = (text) => text.split(/\r?\n/);
+exports.lines = lines;
+const chars = (text) => text.split('');
+exports.chars = chars;

package/dist/runtime/bk-text.d.ts

@@ -0,0 +1,5 @@
+export declare const trim: (text: string) => string;
+export declare const upper: (text: string) => string;
+export declare const lower: (text: string) => string;
+export declare const split: (text: string, sep?: string) => string[];
+export declare const join: (list: string[], sep?: string) => string;

package/dist/runtime/bk-text.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = exports.split = exports.lower = exports.upper = exports.trim = void 0;
+const trim = (text) => text.trim();
+exports.trim = trim;
+const upper = (text) => text.toUpperCase();
+exports.upper = upper;
+const lower = (text) => text.toLowerCase();
+exports.lower = lower;
+const split = (text, sep) => sep ? text.split(sep) : text.split(' ');
+exports.split = split;
+const join = (list, sep = '') => list.join(sep);
+exports.join = join;

package/dist/runtime/rtj-core.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/rtj-core.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules = {};
+function registerModule(name, fns) {
+    modules[name] = fns;
+}
+function talk(value) {
+    console.log(value);
+}
+const bkText = __importStar(require("./bk-text"));
+const bkParse = __importStar(require("./bk-parse"));
+const atlData = __importStar(require("./atl-data"));
+const atlFlow = __importStar(require("./atl-flow"));
+registerModule('bk:text', bkText);
+registerModule('bk:parse', bkParse);
+registerModule('atl:data', atlData);
+registerModule('atl:flow', atlFlow);
+module.exports = { talk, modules };

package/dist/semantic.d.ts

@@ -0,0 +1,11 @@
+import { Program } from './ast';
+export declare class Semantic {
+    private scopes;
+    analyze(program: Program): void;
+    private pushScope;
+    private popScope;
+    private declare;
+    private lookup;
+    private analyzeStatement;
+    private analyzeExpression;
+}

package/dist/semantic.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Semantic = void 0;
+const diagnostics_1 = require("./diagnostics");
+const VALID_MODULES = ['bk:text', 'bk:parse', 'atl:data', 'atl:flow'];
+class Semantic {
+    constructor() {
+        this.scopes = [];
+    }
+    analyze(program) {
+        this.pushScope();
+        for (const stmt of program.body) {
+            this.analyzeStatement(stmt);
+        }
+        this.popScope();
+    }
+    pushScope() {
+        this.scopes.push(new Set());
+    }
+    popScope() {
+        this.scopes.pop();
+    }
+    declare(name, line) {
+        const top = this.scopes[this.scopes.length - 1];
+        if (top.has(name)) {
+            throw new diagnostics_1.RTJError('NameError', `duplicate jewel '${name}'`, line);
+        }
+        top.add(name);
+    }
+    lookup(name) {
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            if (this.scopes[i].has(name))
+                return true;
+        }
+        return false;
+    }
+    analyzeStatement(stmt) {
+        switch (stmt.type) {
+            case 'VarDecl':
+                this.analyzeExpression(stmt.init);
+                this.declare(stmt.name, stmt.loc.line);
+                break;
+            case 'FunctionDecl':
+                this.declare(stmt.name, stmt.loc.line);
+                this.pushScope();
+                for (const p of stmt.params) {
+                    this.declare(p, stmt.loc.line);
+                }
+                for (const s of stmt.body.body) {
+                    this.analyzeStatement(s);
+                }
+                this.popScope();
+                break;
+            case 'ReturnStmt':
+                if (stmt.value)
+                    this.analyzeExpression(stmt.value);
+                break;
+            case 'TalkStmt':
+                this.analyzeExpression(stmt.value);
+                break;
+            case 'IfStmt':
+                this.analyzeExpression(stmt.condition);
+                this.pushScope();
+                for (const s of stmt.consequent.body)
+                    this.analyzeStatement(s);
+                this.popScope();
+                if (stmt.alternate) {
+                    this.pushScope();
+                    for (const s of stmt.alternate.body)
+                        this.analyzeStatement(s);
+                    this.popScope();
+                }
+                break;
+            case 'LoopStmt':
+                this.analyzeExpression(stmt.iterable);
+                this.pushScope();
+                this.declare(stmt.variable, stmt.loc.line);
+                for (const s of stmt.body.body)
+                    this.analyzeStatement(s);
+                this.popScope();
+                break;
+            case 'ImportStmt':
+                if (!VALID_MODULES.includes(stmt.source)) {
+                    throw new diagnostics_1.RTJError('ImportError', `unknown feature source '${stmt.source}'`, stmt.loc.line);
+                }
+                for (const name of stmt.names) {
+                    this.declare(name, stmt.loc.line);
+                }
+                break;
+            case 'ThrowStmt':
+                this.analyzeExpression(stmt.value);
+                break;
+            case 'ExpressionStmt':
+                this.analyzeExpression(stmt.expr);
+                break;
+            case 'BlockStmt':
+                this.pushScope();
+                for (const s of stmt.body)
+                    this.analyzeStatement(s);
+                this.popScope();
+                break;
+        }
+    }
+    analyzeExpression(expr) {
+        switch (expr.type) {
+            case 'Identifier':
+                // Warn but don't error in v0.1 (runtime may provide)
+                break;
+            case 'StringLiteral':
+            case 'NumberLiteral':
+            case 'BooleanLiteral':
+            case 'NullLiteral':
+                break;
+            case 'ArrayLiteral':
+                for (const el of expr.elements)
+                    this.analyzeExpression(el);
+                break;
+            case 'ObjectLiteral':
+                for (const pair of expr.pairs)
+                    this.analyzeExpression(pair.value);
+                break;
+            case 'BinaryExpr':
+                this.analyzeExpression(expr.left);
+                this.analyzeExpression(expr.right);
+                break;
+            case 'UnaryExpr':
+                this.analyzeExpression(expr.operand);
+                break;
+            case 'CallExpr':
+                this.analyzeExpression(expr.callee);
+                for (const arg of expr.args)
+                    this.analyzeExpression(arg);
+                break;
+            case 'MemberExpr':
+                this.analyzeExpression(expr.object);
+                if (expr.computed)
+                    this.analyzeExpression(expr.property);
+                break;
+            case 'PipeExpr':
+                for (const step of expr.steps)
+                    this.analyzeExpression(step);
+                break;
+            case 'DuoExpr':
+                this.analyzeExpression(expr.input);
+                for (const step of expr.mikePipeline)
+                    this.analyzeExpression(step);
+                for (const step of expr.elPipeline)
+                    this.analyzeExpression(step);
+                break;
+        }
+    }
+}
+exports.Semantic = Semantic;

package/dist/tests/basic.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/basic.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const semantic_1 = require("../semantic");
+const generator_1 = require("../generator");
+function compile(source) {
+    const lexer = new lexer_1.Lexer(source);
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens);
+    const ast = parser.parse();
+    const semantic = new semantic_1.Semantic();
+    semantic.analyze(ast);
+    const gen = new generator_1.Generator();
+    return gen.generate(ast);
+}
+function test(name, fn) {
+    try {
+        fn();
+        console.log(`PASS: ${name}`);
+    }
+    catch (err) {
+        console.error(`FAIL: ${name}`);
+        console.error(err);
+        process.exitCode = 1;
+    }
+}
+function assert(condition, msg) {
+    if (!condition)
+        throw new Error(`Assertion failed: ${msg}`);
+}
+test('lexer tokenizes hello world', () => {
+    const lexer = new lexer_1.Lexer('talk "hello"');
+    const tokens = lexer.tokenize();
+    assert(tokens[0].type === 'TALK', 'first token is TALK');
+    assert(tokens[1].type === 'STRING', 'second token is STRING');
+    assert(tokens[1].value === 'hello', 'string value is hello');
+});
+test('parser creates TalkStmt', () => {
+    const lexer = new lexer_1.Lexer('talk "hello"');
+    const tokens = lexer.tokenize();
+    const parser = new parser_1.Parser(tokens);
+    const ast = parser.parse();
+    assert(ast.body.length === 1, 'one statement');
+    assert(ast.body[0].type === 'TalkStmt', 'is TalkStmt');
+});
+test('generator outputs talk call', () => {
+    const js = compile('talk "hello"');
+    assert(js.includes('__rtj.talk("hello")'), 'contains talk call');
+});
+test('pipe expression compiles to nested calls', () => {
+    const js = compile('feature trim, upper from "bk:text"\njewel x = "hi" |> trim |> upper');
+    assert(js.includes('upper(trim("hi"))'), 'pipe flattened correctly');
+});
+test('duo expression compiles', () => {
+    const js = compile('feature trim from "bk:text"\nfeature words from "bk:parse"\nfeature count from "atl:data"\njewel x = duo("hi") {\n  mike: trim |> words\n  el: count\n}');
+    assert(js.includes('count(words(trim("hi")))'), 'duo flattened correctly');
+});
+test('semantic rejects invalid import source', () => {
+    let threw = false;
+    try {
+        compile('feature foo from "bk:audio"');
+    }
+    catch (err) {
+        threw = true;
+    }
+    assert(threw, 'should throw on invalid import');
+});
+console.log('All tests complete.');

package/dist/token.d.ts

@@ -0,0 +1,56 @@
+export declare enum TokenType {
+    JEWEL = "JEWEL",
+    VERSE = "VERSE",
+    SEND = "SEND",
+    TALK = "TALK",
+    IFWILD = "IFWILD",
+    ELSEWILD = "ELSEWILD",
+    RUN = "RUN",
+    IN = "IN",
+    FEATURE = "FEATURE",
+    FROM = "FROM",
+    YANK = "YANK",
+    DUO = "DUO",
+    MIKE = "MIKE",
+    EL = "EL",
+    IDENTIFIER = "IDENTIFIER",
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    NULL = "NULL",
+    PIPE = "PIPE",
+    PLUS = "PLUS",
+    MINUS = "MINUS",
+    STAR = "STAR",
+    SLASH = "SLASH",
+    PERCENT = "PERCENT",
+    EQ_EQ = "EQ_EQ",
+    BANG_EQ = "BANG_EQ",
+    GT = "GT",
+    LT = "LT",
+    GT_EQ = "GT_EQ",
+    LT_EQ = "LT_EQ",
+    AND_AND = "AND_AND",
+    OR_OR = "OR_OR",
+    BANG = "BANG",
+    ASSIGN = "ASSIGN",
+    LBRACE = "LBRACE",
+    RBRACE = "RBRACE",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    COMMA = "COMMA",
+    COLON = "COLON",
+    DOT = "DOT",
+    SEMICOLON = "SEMICOLON",
+    NEWLINE = "NEWLINE",
+    EOF = "EOF"
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+export declare const KEYWORDS: Record<string, TokenType>;

package/dist/token.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEYWORDS = exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    // Keywords
+    TokenType["JEWEL"] = "JEWEL";
+    TokenType["VERSE"] = "VERSE";
+    TokenType["SEND"] = "SEND";
+    TokenType["TALK"] = "TALK";
+    TokenType["IFWILD"] = "IFWILD";
+    TokenType["ELSEWILD"] = "ELSEWILD";
+    TokenType["RUN"] = "RUN";
+    TokenType["IN"] = "IN";
+    TokenType["FEATURE"] = "FEATURE";
+    TokenType["FROM"] = "FROM";
+    TokenType["YANK"] = "YANK";
+    TokenType["DUO"] = "DUO";
+    TokenType["MIKE"] = "MIKE";
+    TokenType["EL"] = "EL";
+    // Literals
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["STRING"] = "STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    // Operators
+    TokenType["PIPE"] = "PIPE";
+    TokenType["PLUS"] = "PLUS";
+    TokenType["MINUS"] = "MINUS";
+    TokenType["STAR"] = "STAR";
+    TokenType["SLASH"] = "SLASH";
+    TokenType["PERCENT"] = "PERCENT";
+    TokenType["EQ_EQ"] = "EQ_EQ";
+    TokenType["BANG_EQ"] = "BANG_EQ";
+    TokenType["GT"] = "GT";
+    TokenType["LT"] = "LT";
+    TokenType["GT_EQ"] = "GT_EQ";
+    TokenType["LT_EQ"] = "LT_EQ";
+    TokenType["AND_AND"] = "AND_AND";
+    TokenType["OR_OR"] = "OR_OR";
+    TokenType["BANG"] = "BANG";
+    TokenType["ASSIGN"] = "ASSIGN";
+    // Punctuation
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACKET"] = "LBRACKET";
+    TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["COLON"] = "COLON";
+    TokenType["DOT"] = "DOT";
+    TokenType["SEMICOLON"] = "SEMICOLON";
+    // Special
+    TokenType["NEWLINE"] = "NEWLINE";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (exports.TokenType = TokenType = {}));
+exports.KEYWORDS = {
+    jewel: TokenType.JEWEL,
+    verse: TokenType.VERSE,
+    send: TokenType.SEND,
+    talk: TokenType.TALK,
+    ifwild: TokenType.IFWILD,
+    elsewild: TokenType.ELSEWILD,
+    run: TokenType.RUN,
+    in: TokenType.IN,
+    feature: TokenType.FEATURE,
+    from: TokenType.FROM,
+    yank: TokenType.YANK,
+    duo: TokenType.DUO,
+    mike: TokenType.MIKE,
+    el: TokenType.EL,
+    true: TokenType.BOOLEAN,
+    false: TokenType.BOOLEAN,
+    null: TokenType.NULL,
+};

package/examples/cities.rtj

@@ -0,0 +1,11 @@
+feature upper from "bk:text"
+feature first, last from "atl:data"
+
+jewel cities = ["Atlanta", "Brooklyn", "Chicago"]
+
+verse announce(city) {
+  send city |> upper
+}
+
+talk announce(first(cities))
+talk announce(last(cities))

package/examples/count-words.rtj

@@ -0,0 +1,12 @@
+feature trim, lower from "bk:text"
+feature words from "bk:parse"
+feature countBy from "atl:data"
+
+jewel verse = "run the jewels run the jewels run"
+
+jewel freq = duo(verse) {
+  mike: trim |> lower |> words
+  el: countBy
+}
+
+talk freq

package/examples/duo.rtj

@@ -0,0 +1,12 @@
+feature trim from "bk:text"
+feature words from "bk:parse"
+feature count from "atl:data"
+
+jewel bars = "  rtj from atlanta to brooklyn  "
+
+jewel total = duo(bars) {
+  mike: trim |> words
+  el: count
+}
+
+talk total

package/examples/hello.rtj

@@ -0,0 +1 @@
+talk "Run The Jewels forever"