text:
(function ()
{
    /*******/
    var ASTHelper = Firecrow.ASTHelper;
    var ValueTypeHelper = Firecrow.ValueTypeHelper;

    Firecrow.CodeMarkupSerializer =
    {
        generateHtmlRepresentation: function(root)
        {
            var root = root.htmlElement != null ? root : root.model;

            try
            {
                return "
" //generate the main container
                    + this.generateHtmlDocumentTypeTags(root.docType) // generate the HTML Document Type Definition
                    + this.generateHtmlElement(root.htmlElement)
                    + '
';
            }
            catch(e)
            {
                console.log("Error while creating a HTML representation of the site: " + e);
            }
        },

        generateHtmlDocumentTypeTags: function(documentType)
        {
            var docTypeHtml = '
';

            if (documentType == "") { docTypeHtml += '<!DOCTYPE html>'; }
            else if (documentType === "http://www.w3.org/TR/html4/strict.dtd") { docTypeHtml += '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">';}
            else if (documentType === "http://www.w3.org/TR/html4/loose.dtd") { docTypeHtml += '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'; }
            else if (documentType === "http://www.w3.org/TR/html4/frameset.dtd") { docTypeHtml += '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'; }
            else if (documentType === "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd") { docTypeHtml += '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'; }
            else if (documentType === "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd") { docTypeHtml += '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'; }
            else if (documentType === "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd") { docTypeHtml += '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'; }
            else if (documentType === "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd") { docTypeHtml += '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'; }
            else { return "";}

            docTypeHtml += '
';

            return docTypeHtml;
        },

        generateOpeningTags: function (elementType, elementAttributes)
        {
            if(elementType === 'textNode' || elementAttributes == null) { return ''};

            var html = '';

            // generate <elementType attribute[0].name="attribute[0].value" ... attribute[N].name="attribute[N].value">
            // <elementType
            html += '<' + elementType + '';

            for (var i = 0; i < elementAttributes.length; i++)
            {
                html += ' ' + elementAttributes[i].name + '=';
                html += '"' + elementAttributes[i].value + '"';
            }
            // generate >
            html += '>';

            return html;
        },

        generateClosingTags: function (elementType)
        {
            if(elementType === "textNode") { return "" };

            return '</' + elementType + ">";
        },

        generateHtmlElement: function(element)
        {
            try
            {
                if(element.type == "textNode") { return element.textContent.trim() != "" ? "" + element.textContent + "" : ""; }

                var html = '
'
                    + this.generateOpeningTags(element.type, element.attributes);

                if (element.type === "script")
                {
                    html += this.generateHtml(element.pathAndModel.model);
                }
                else if (element.type === "link")
                {
                    // Check if the link is a stylesheet
                    var isLinkStyleSheet = false;

                    for (var i = 0; i < element.attributes.length; i++)
                    {
                        var attribute = element.attributes[i];
                        if (attribute != undefined)
                        {
                            if (attribute.name === "rel" && attribute.value.toLowerCase() == "stylesheet"
                                ||  attribute.name === "type" && attribute.value.toLowerCase() === "text/css")
                            {
                                html += this.generateCSSRepresentation(element.pathAndModel.model);
                            }
                        }
                    }
                }
                else if (element.type === "style")
                {
                    html += this.generateCSSRepresentation(element.pathAndModel.model);
                }
                else
                {
                    if(element.textContent != undefined) { html += element.textContent; }

                    if(element.childNodes != null)
                    {
                        for(var i=0; i < element.childNodes.length; i++)
                        {
                            html += this.generateHtmlElement(element.childNodes[i]);
                        }
                    }
                }

                if(this.doesElementHaveClosingTags(element.type))
                {
                    html += this.generateClosingTags(element.type);
                }

                html += '
';

                return html;
            }
            catch(e)
            {
                debugger;
                alert("Error while generating a html element: " + e);
            }
        },

        generateCSSRepresentation: function(cssModel)
        {
            try
            {
                var html = "
";
                var cssRules = "";
                var rulesArray = [];
                for(var i = 0; i < cssModel.rules.length; i++)
                {
                    // if rule is @charset
                    if (cssModel.rules[i].cssText[0] == "@")
                    {
                        html += '
' + cssModel.rules[i].cssText + '
';
                    }
                    else
                    {
                        cssRules = cssModel.rules[i].cssText.replace(cssModel.rules[i].selector, "");

                        cssRules = cssRules.replace("{", "");
                        cssRules = cssRules.replace("}", "");
                        while(cssRules[0] === " ")
                            cssRules = cssRules.replace(" ", "");

                        html += '
';
                        //html += '' + cssModel.rules[i].selector + "
";
                        html += '' + cssModel.rules[i].selector + '
';
                        html += "{
";

                        rulesArray = cssRules.split("; ");

                        for(var j = 0; j < rulesArray.length; j++)
                        {
                            if(rulesArray[j] != "")
                                html += "" + rulesArray[j] + ";
";
                        }
                        html += '}
';
                    }
                }

                html += "
";
                return html;
            }
            catch(e)
            {
                alert("Error while generating HTML representation of CSS: " + e);
            }
        },

        doesElementHaveClosingTags: function(elementType)
        {
            return !(elementType === "area"
                || elementType === "base"
                || elementType === "br"
                || elementType === "basefont"
                || elementType === "col"
                || elementType === "frame"
                || elementType ===  "hr"
                || elementType === "img"
                || elementType === "input"
                || elementType === "meta"
                || elementType === "param");
        },

        generateHtml: function(element)
        {
            try
            {
                if(element == null) { return ""; }

                if (ASTHelper.isProgram(element)) { return this.generateProgram(element); }
                else if (ASTHelper.isStatement(element)) { return this.generateStatement(element); }
                else if (ASTHelper.isExpression(element)) { return this.generateExpression(element); }
                else if (ASTHelper.isSwitchCase(element)) { return this.generateFromSwitchCase(element); }
                else if (ASTHelper.isCatchClause(element)) { return this.generateFromCatchClause(element); }
                else if (ASTHelper.isFunction(element)) { return this.generateFromFunction(element); }
                else if (ASTHelper.isVariableDeclaration(element)) { return this.generateFromVariableDeclaration(element); }
                else if (ASTHelper.isVariableDeclarator(element)) { return this.generateFromVariableDeclarator(element); }
                else if (ASTHelper.isLiteral(element)) { return this.generateFromLiteral(element); }
                else if (ASTHelper.isIdentifier(element)) { return this.generateFromIdentifier(element); }
                else
                {
                    alert("Error while generating HTML in CodeMarkupSerializer: unidentified ast element.");
                    return "";
                }
            }
            catch(e)
            {
                debugger;
                alert("Error while generating HTML in CodeMarkupSerializer: " + e);
            }
        },

        generateProgram: function(program)
        {
            try
            {
                var html = "
";
                var body = program.body;

                for(var i = 0; i < body.length; i++)
                {
                    html += this.generateHtml(body[i]);
                }

                return html + "
";
            }
            catch(e)
            {
                alert("Error when generating program HTML");
            }
        },

        generateStatement: function(statement)
        {
            try
            {
                if (ASTHelper.isEmptyStatement(statement))  { return this.generateFromEmptyStatement(statement); }
                else if (ASTHelper.isBlockStatement(statement)) { return this.generateFromBlockStatement(statement); }
                else if (ASTHelper.isExpressionStatement(statement)) { return this.generateFromExpressionStatement(statement); }
                else if (ASTHelper.isIfStatement(statement)) { return this.generateFromIfStatement(statement); }
                else if (ASTHelper.isWhileStatement(statement)) { return this.generateFromWhileStatement(statement); }
                else if (ASTHelper.isDoWhileStatement(statement)) { return this.generateFromDoWhileStatement(statement); }
                else if (ASTHelper.isForStatement(statement)) { return this.generateFromForStatement(statement); }
                else if (ASTHelper.isForInStatement(statement)) { return this.generateFromForInStatement(statement); }
                else if (ASTHelper.isLabeledStatement(statement)) { return this.generateFromLabeledStatement(statement); }
                else if (ASTHelper.isBreakStatement(statement)) { return this.generateFromBreakStatement(statement); }
                else if (ASTHelper.isContinueStatement(statement)) { return this.generateFromContinueStatement(statement); }
                else if (ASTHelper.isReturnStatement(statement)) { return this.generateFromReturnStatement(statement); }
                else if (ASTHelper.isWithStatement(statement)) { return this.generateFromWithStatement(statement); }
                else if (ASTHelper.isTryStatement(statement)) { return this.generateFromTryStatement(statement); }
                else if (ASTHelper.isThrowStatement(statement)) { return this.generateFromThrowStatement(statement); }
                else if (ASTHelper.isSwitchStatement(statement)) { return this.generateFromSwitchStatement(statement); }
                else
                {
                    alert("Error: AST Statement element not defined: " + statement.type);
                    return "";
                }
            }
            catch(e)
            {
                debugger;
                alert("Error when generating HTML from a statement: " + e);
            }
        },

        generateExpression: function(expression)
        {
            try
            {
                if (ASTHelper.isAssignmentExpression(expression)) { return this.generateFromAssignmentExpression(expression); }
                else if (ASTHelper.isUnaryExpression(expression)) { return this.generateFromUnaryExpression(expression); }
                else if (ASTHelper.isBinaryExpression(expression)) { return this.generateFromBinaryExpression(expression); }
                else if (ASTHelper.isLogicalExpression(expression)) { return this.generateFromLogicalExpression(expression); }
                else if (ASTHelper.isLiteral(expression)) { return this.generateFromLiteral(expression); }
                else if (ASTHelper.isIdentifier(expression)) { return this.generateFromIdentifier(expression); }
                else if (ASTHelper.isUpdateExpression(expression)) { return this.generateFromUpdateExpression(expression); }
                else if (ASTHelper.isNewExpression(expression)) { return this.generateFromNewExpression(expression); }
                else if (ASTHelper.isConditionalExpression(expression)) { return this.generateFromConditionalExpression(expression); }
                else if (ASTHelper.isThisExpression(expression)) { return this.generateFromThisExpression(expression); }
                else if (ASTHelper.isCallExpression(expression)) { return this.generateFromCallExpression(expression); }
                else if (ASTHelper.isMemberExpression(expression)) { return this.generateFromMemberExpression(expression); }
                else if (ASTHelper.isSequenceExpression(expression)) { return this.generateFromSequenceExpression(expression); }
                else if (ASTHelper.isArrayExpression(expression)) { return this.generateFromArrayExpression(expression); }
                else if (ASTHelper.isObjectExpression(expression)) { return this.generateFromObjectExpression(expression); }
                else if (ASTHelper.isFunctionExpression(expression)) { return this.generateFromFunction(expression, true); }
                else
                {
                    alert("Error: AST Expression element not defined: " + expression.type);  return "";
                }
            }
            catch(e)
            {
                alert("Error when generating HTML from an expression:" + e);
            }
        },

        generateFromFunction: function(functionDecExp)
        {
            try
            {
                var _class = functionDecExp.type + " node" + this._generateHasBeenExecutedClass(functionDecExp);
                var _id = "node" + this.formatId(functionDecExp.nodeId);
                var _style = this.getStyle(functionDecExp);

                var nodeType = ASTHelper.isFunctionExpression(functionDecExp) ? "span" : "div";

                var shouldBeInParentheses = ASTHelper.isFunctionExpression(functionDecExp)
                    && ASTHelper.isCallExpressionCallee(functionDecExp);

                return this.getStartElementHtml(nodeType, { class: _class, id : _id, style: _style })
                    + (shouldBeInParentheses ? this._LEFT_PARENTHESIS : "")
                    + this.getElementHtml("span", {class: "keyword"}, this._FUNCTION_KEYWORD) + " " + (functionDecExp.id != null ? this.generateFromIdentifier(functionDecExp.id) + " " : "")
                    + this.generateFunctionParametersHtml(functionDecExp)
                    + this.generateFromFunctionBody(functionDecExp)
                    + (shouldBeInParentheses ? this._RIGHT_PARENTHESIS : "")
                    + this.getEndElementHtml(nodeType);
            }
            catch(e)
            {
                alert("Error when generating HTML from a function:" + e);
            }
        },

        generateFunctionParametersHtml: function(functionDecExp)
        {
            var html = this._LEFT_PARENTHESIS;

            for(var i = 0; i < functionDecExp.params.length; i++)
            {
                if(i != 0) { html += ", "; }

                html += this.generateFromPattern(functionDecExp.params[i]);
            }

            return html + this._RIGHT_PARENTHESIS;
        },

        generateFromFunctionBody: function(functionDeclExp)
        {
            return this.generateHtml(functionDeclExp.body);
        },

        generateFromBlockStatement: function(blockStatement)
        {
            var html = this.getStartElementHtml( "div",
                {
                    class: ASTHelper.CONST.STATEMENT.BlockStatement + " node",
                    id: "node" + this.formatId(blockStatement.nodeId)
                })
                + this.getElementHtml("div", {class: "Bracket"}, "{");

            var body = blockStatement.body;
            for(var i = 0, length = body.length; i < length; i++)
            {
                html += this.generateHtml(body[i]);
            }

            return html + this.getElementHtml("div", {class: "Bracket"}, "}")
                + this.getEndElementHtml("div");
        },

        generateFromEmptyStatement: function(emptyStatement)
        {
            return this.getElementHtml("div",
                {
                    class: ASTHelper.CONST.STATEMENT.EmptyStatement + " node",
                    id: "node" + this.formatId(emptyStatement.nodeId),
                    style: this.getStyle(emptyStatement)
                }, ";");
        },

        generateFromExpressionStatement: function(expressionStatement)
        {
            return this.getStartElementHtml("div",
                {
                    class: ASTHelper.CONST.STATEMENT.ExpressionStatement + " node" + this._generateHasBeenExecutedClass(expressionStatement),
                    id: "node" + this.formatId(expressionStatement.nodeId),
                    style: this.getStyle(expressionStatement)
                })
                + this.generateHtml(expressionStatement.expression)
                + this.getEndElementHtml("div");
        },

        generateFromAssignmentExpression: function(assignmentExpression)
        {
            var shouldBeSurrounded = ASTHelper.isBinaryExpression(assignmentExpression.parent)
                || ASTHelper.isLogicalExpression(assignmentExpression.parent);

            return (shouldBeSurrounded ? this._LEFT_PARENTHESIS : "")
                + this.getStartElementHtml("span",
                    {
                        class: ASTHelper.CONST.EXPRESSION.AssignmentExpression + " node",
                        id: "node" + this.formatId(assignmentExpression.nodeId)
                    })
                + this.generateHtml(assignmentExpression.left)
                + " " + assignmentExpression.operator + " "
                + this.generateHtml(assignmentExpression.right)
                + this.getEndElementHtml("span")
                + (shouldBeSurrounded ? this._RIGHT_PARENTHESIS : "");
        },

        generateFromUnaryExpression: function(unaryExpression)
        {
            var html = this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.UnaryExpression + " node",
                    id: "node" + this.formatId(unaryExpression.nodeId)
                });

            if(unaryExpression.prefix) { html += unaryExpression.operator; }

            if(unaryExpression.operator == "typeof"
                || unaryExpression.operator == "void"
                || unaryExpression.operator == "delete")
            {
                html += " ";
            }

            var isComplexArgument = !(ASTHelper.isLiteral(unaryExpression.argument) || ASTHelper.isIdentifier(unaryExpression.argument));

            html += (isComplexArgument ? this._LEFT_PARENTHESIS : "")
                + this.generateExpression(unaryExpression.argument)
                + (isComplexArgument ? this._RIGHT_PARENTHESIS : "");

            if(!unaryExpression.prefix) { html += unaryExpression.operator; }

            html += this.getEndElementHtml("span");

            return html;
        },

        generateFromBinaryExpression: function(binaryExpression)
        {
            return this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.BinaryExpression + " node",
                    id: "node" + this.formatId(binaryExpression.nodeId)
                })
                + this.generateHtml(binaryExpression.left)
                + " " + binaryExpression.operator + " "
                + this.generateHtml(binaryExpression.right)
                + this.getEndElementHtml("span");
        },

        generateFromLogicalExpression: function(logicalExpression)
        {
            var _class = ASTHelper.CONST.EXPRESSION.LogicalExpression + " node";
            var _id = "node" + this.formatId(logicalExpression.nodeId);

            var shouldBeSurrounded = ASTHelper.isBinaryExpression(logicalExpression.parent)
                || (ASTHelper.isLogicalExpression(logicalExpression.parent) && logicalExpression.parent.operator != logicalExpression.operator)
                || (ASTHelper.isCallExpression(logicalExpression.parent) && logicalExpression.parent.callee == logicalExpression);

            return (shouldBeSurrounded ? this._LEFT_PARENTHESIS : "")
                + this.getStartElementHtml("span",
                    {
                        class: _class,
                        id: _id
                    })
                + this.generateHtml(logicalExpression.left)
                + " " + logicalExpression.operator + " "
                + this.generateHtml(logicalExpression.right)
                + this.getEndElementHtml("span")
                + (shouldBeSurrounded ? this._RIGHT_PARENTHESIS : "")
        },

        generateFromUpdateExpression: function(updateExpression)
        {
            var html = this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.UpdateExpression + " node",
                    id: "node" + this.formatId(updateExpression.nodeId)
                });

            // if prefixed e.g.: ++i
            if(updateExpression.prefix) html += updateExpression.operator;

            html += this.generateHtml(updateExpression.argument);

            // if postfixed e.g.: i++
            if(!updateExpression.prefix) html += updateExpression.operator;

            return html + this.getEndElementHtml("span");
        },

        generateFromNewExpression: function(newExpression)
        {
            return this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.NewExpression + " node",
                    id: "node" + this.formatId(newExpression.nodeId)
                })
                + this.getElementHtml("span", {class: "keyword"}, "new ")
                + this.generateHtml(newExpression.callee)
                + this._LEFT_PARENTHESIS
                + this.getSequenceHtml(newExpression.arguments)
                + this._RIGHT_PARENTHESIS
                + this.getEndElementHtml("span");
        },

        generateFromConditionalExpression: function(conditionalExpression)
        {
            var shouldBeSurrounded = ASTHelper.isBinaryExpression(conditionalExpression.parent)
                || ASTHelper.isLogicalExpression(conditionalExpression.parent)
                || ASTHelper.isCallExpressionCallee(conditionalExpression);

            return (shouldBeSurrounded ? this._LEFT_PARENTHESIS : "")
                + this.getStartElementHtml("span",
                    {
                        class: ASTHelper.CONST.EXPRESSION.ConditionalExpression + " node",
                        id: "node" + this.formatId(conditionalExpression.nodeId)
                    })
                + this.generateHtml(conditionalExpression.test)
                + " ? " + this.generateHtml(conditionalExpression.consequent)
                + " : " + this.generateHtml(conditionalExpression.alternate)
                + this.getEndElementHtml("span")
                + (shouldBeSurrounded ? this._RIGHT_PARENTHESIS : "");
        },

        generateFromThisExpression: function(thisExpression)
        {
            return this.getElementHtml("span",
                {
                    class: "keyword node",
                    id: "node" + this.formatId(thisExpression.nodeId)
                }, "this");
        },

        generateFromCallExpression: function(callExpression)
        {
            return this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.CallExpression + " node",
                    id: "node" + this.formatId(callExpression.nodeId)
                })
                + this.generateHtml(callExpression.callee) + this._LEFT_PARENTHESIS
                + this.getSequenceHtml(callExpression.arguments)
                + this._RIGHT_PARENTHESIS + this.getEndElementHtml("span");
        },

        generateFromMemberExpression: function(memberExpression)
        {
            var isNotSimpleMemberExpression = !ASTHelper.isIdentifier(memberExpression.object)
                &&!ASTHelper.isCallExpression(memberExpression.object)
                &&!ASTHelper.isThisExpression(memberExpression.object)
                &&!ASTHelper.isMemberExpression(memberExpression.object);

            var html = this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.MemberExpression + " node",
                    id: "node" + this.formatId(memberExpression.nodeId)
                })
                + this.generateHtml(memberExpression.object);

            var isPropertyStringLiteral = ASTHelper.isStringLiteral(memberExpression.property);

            if(memberExpression.computed || isPropertyStringLiteral)
            {
                html += this._LEFT_BRACKET
                    + (isPropertyStringLiteral ? "'" : "")
                    +  this.generateHtml(memberExpression.property)
                    + (isPropertyStringLiteral ? "'" : "")
                    + this._RIGHT_BRACKET;
            }
            else
            {
                html += "." + this.generateHtml(memberExpression.property);
            }

            return (isNotSimpleMemberExpression ? this._LEFT_PARENTHESIS : "")
                + html + this.getEndElementHtml("span")
                + (isNotSimpleMemberExpression ? this._RIGHT_PARENTHESIS : "")
        },

        generateFromSequenceExpression: function(sequenceExpression)
        {
            return this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.SequenceExpression + " node",
                    id: "node" + this.formatId(sequenceExpression.nodeId)
                })
                + this.getSequenceHtml(sequenceExpression.expressions)
                + this.getEndElementHtml("span");
        },

        generateFromArrayExpression: function(arrayExpression)
        {
            return this.getStartElementHtml("span",
                {
                    class: ASTHelper.CONST.EXPRESSION.ArrayExpression + " node",
                    id: "node" + this.formatId(arrayExpression.nodeId)
                })
                + this._LEFT_BRACKET
                + this.getSequenceHtml(arrayExpression.elements)
                + this._RIGHT_BRACKET
                + this.getEndElementHtml("span");
        },

        generateFromObjectExpression: function(objectExpression)
        {
            var _style = this.getStyle(objectExpression);
            var _id = "node" + this.formatId(objectExpression.nodeId);
            var _class = ASTHelper.CONST.EXPRESSION.ObjectExpression + " node";

            var _containerStyle = "display: block";
            var _propertyContainerStyle = "";

            var _isEmptyObject = objectExpression.properties.length == 0;

            var _hasGettersOrSetters = false;
            var _hasMoreThanTwoProperties = objectExpression.properties.length > 2;
            var _hasFunctionExpressions = false;

            var properties = objectExpression.properties;

            for(var i = 0; i < properties.length; i++)
            {
                var property = properties[i];

                if (property.kind == "get" || property.kind == "set")
                {
                    _hasGettersOrSetters = true;
                }

                if (ASTHelper.isFunctionExpression(property.value))
                {
                    _hasFunctionExpressions = true;
                }
            }

            if (_isEmptyObject == true || (_hasMoreThanTwoProperties == false && _hasFunctionExpressions == false && _hasGettersOrSetters == false))
            {
                _containerStyle = "display: inline;";
                _propertyContainerStyle = "display: inline;";
            }
            else
            {
                _containerStyle = "display: block;";
                _propertyContainerStyle = "display: block; padding-left: 20px;";
            }

            var html = this.getStartElementHtml("div", { class: _class, style: _containerStyle, id: _id });

            if (_isEmptyObject) { html += "{}"; }
            else
            {
                html += '{';

                for (var i = 0; i < properties.length; i++)
                {
                    var property = properties[i];

                    html += '
';

                    if (property.kind == "init")
                    {
                        html += this.generateHtml(property.key) + ': '
                            + this.generateHtml(property.value);
                    }
                    else
                    {
                        html += this.getElementHtml("span", {class: "keyword"}, property.kind) + " " + this.generateHtml(property.key)
                            + this.generateExpression(property.value);
                    }

                    if(i != properties.length - 1) { html += ", "; }

                    html += '
';
                }

                html += '}'
            }

            return html + this.getEndElementHtml("div");
        },

        generateFromIfStatement: function(ifStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.IfStatement + " node" + this._generateHasBeenExecutedClass(ifStatement);
            var _id = "node" + this.formatId(ifStatement.nodeId);
            var _style = "display: inline";

            var html = this.getStartElementHtml("div", {class: _class, style: _style, id: _id})
                + this.getElementHtml("span", {class:"keyword"}, "if")
                + " (" + this.generateHtml(ifStatement.test) + ") ";

            if(!ASTHelper.isBlockStatement(ifStatement.consequent))
                html += "
";

            html += this.generateHtml(ifStatement.consequent);

            if(ifStatement.alternate != null)
            {
                html += this.getElementHtml("span", {class:"keyword", style:"margin-left:20px"}, "else ")
                    + this.generateHtml(ifStatement.alternate);
            }

            html += this.getEndElementHtml("div");

            return html;
        },

        generateFromWhileStatement: function(whileStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.WhileStatement + " node" + this._generateHasBeenExecutedClass(whileStatement);
            var _id = "node" + this.formatId(whileStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class:"keyword"}, "while")
                + "(" + this.generateHtml(whileStatement.test) + ")  ";

            html += this.generateHtml(whileStatement.body)
                + this.getEndElementHtml("div");

            return html;
        },

        generateFromDoWhileStatement: function(doWhileStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.DoWhileStatement + " node" + this._generateHasBeenExecutedClass(doWhileStatement);
            var _id = "node" + this.formatId(doWhileStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class:"keyword"}, "do");

            if(!ASTHelper.isBlockStatement(doWhileStatement.body))
                html += "
";

            html += this.generateHtml(doWhileStatement.body);

            html += this.getElementHtml("span", {class:"keyword"}, "while")
                + " (" + this.generateHtml(doWhileStatement.test) + ")"
                + this.getEndElementHtml("div");

            return html;
        },

        generateFromForStatement: function(forStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.ForStatement + " node" + this._generateHasBeenExecutedClass(forStatement);
            var _id = "node" + this.formatId(forStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id});

            html += this.getElementHtml("span", {class:"keyword"}, "for") + " "
                + "(" + this.generateHtml(forStatement.init) + "; "
                + this.generateHtml(forStatement.test) + "; "
                + this.generateHtml(forStatement.update) + ") "
                + this.generateHtml(forStatement.body);

            html += this.getEndElementHtml("div");

            return html;
        },

        generateFromForInStatement: function(forInStatement)
        {
            if(!ASTHelper.isForInStatement(forInStatement))
            {
                alert("Invalid element when generating for...in statement html code!");
                return "";
            }

            var _class = ASTHelper.CONST.STATEMENT.ForInStatement + " node" + this._generateHasBeenExecutedClass(forInStatement);
            var _id = "node" + this.formatId(forInStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id});

            html += this.getElementHtml("span", {class:"keyword"}, "for") + " ";

            if(forInStatement.each === true) html += this.getElementHtml("span", {class:"keyword"}, "each") + " ";

            html += "(" + this.generateHtml(forInStatement.left)
                + " in " + this.generateExpression(forInStatement.right) + ")";

            if(!ASTHelper.isBlockStatement(forInStatement.body))
                html += "
";

            html += this.generateStatement(forInStatement.body);

            html += this.getEndElementHtml("div");

            return html;
        },

        generateFromBreakStatement: function(breakStatement)
        {
            if(!ASTHelper.isBreakStatement(breakStatement))
            {
                alert("Invalid element when generating break statement html code!");
                return "";
            }

            var _class = ASTHelper.CONST.STATEMENT.BreakStatement + " node" + this._generateHasBeenExecutedClass(breakStatement);
            var _id = "node" + this.formatId(breakStatement.nodeId);
            var _style = this.getStyle(breakStatement);

            var html = this.getStartElementHtml("div", {class: _class, id: _id, style: _style})
                + this.getElementHtml("span", {class:"keyword"}, "break");

            if(breakStatement.label != null) html += " " + this.generateFromIdentifier(breakStatement.label);

            html += ";" + this.getEndElementHtml("div");

            return html;
        },

        generateFromContinueStatement: function(continueStatement)
        {
            var _class =  ASTHelper.CONST.STATEMENT.ContinueStatement + " node";
            var _id = "node" + this.formatId(continueStatement.nodeId);
            var _style = this.getStyle(continueStatement);

            var html = this.getStartElementHtml("div", {class: _class, id: _id, style: _style})
                + this.getElementHtml("span", {class:"keyword"}, "continue");

            if(continueStatement.label != null) html += " " + this.generateFromIdentifier(continueStatement.label);

            html += ";" + this.getEndElementHtml("div");

            return html;
        },

        generateFromReturnStatement: function(returnStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.ReturnStatement + " node" + this._generateHasBeenExecutedClass(returnStatement);
            var _id = "node" + this.formatId(returnStatement.nodeId);
            var _style = this.getStyle(returnStatement);

            var html = this.getStartElementHtml("div", {class: _class, id: _id, style: _style})
                + this.getElementHtml("span", {class:"keyword"}, "return");

            if(returnStatement.argument != null) html += " " + this.generateExpression(returnStatement.argument);

            html += ";" + this.getEndElementHtml("div");

            return html;
        },

        generateFromWithStatement: function(withStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.WithStatement + " node" + this._generateHasBeenExecutedClass(withStatement);
            var _id = "node" + this.formatId(withStatement.nodeId);

            return this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class:"keyword"}, "with") + " ("
                + this.generateExpression(withStatement.object) + ")"
                + this.generateStatement(withStatement.body)
                + this.getEndElementHtml("div");
        },

        generateFromThrowStatement: function(throwStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.ThrowStatement + " node";
            var _id =  "node" + this.formatId(throwStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class: "keyword"}, "throw")
                + " " + this.generateExpression(throwStatement.argument)
                + ";" + this.getEndElementHtml("div");

            return html;
        },

        generateFromSwitchStatement: function(switchStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.SwitchStatement + " node" + this._generateHasBeenExecutedClass(switchStatement);
            var _id = "node" + this.formatId(switchStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class: "keyword"}, "switch")
                + " (" + this.generateExpression(switchStatement.discriminant) + ")"
                + "
";

            html += this.getElementHtml("div", {class: "Bracket"}, "{");

            for(var i = 0; i < switchStatement.cases.length; i++)
            {
                html += this.generateFromSwitchCase(switchStatement.cases[i]);
            }

            html += this.getElementHtml("div", {class: "Bracket"}, "}");

            html += this.getEndElementHtml("div");

            return html;
        },

        generateFromSwitchCase: function(switchCase)
        {
            var _class = ASTHelper.CONST.SwitchCase + " node" + this._generateHasBeenExecutedClass(switchCase);
            var _id = "node" + this.formatId(switchCase.nodeId);
            var _style =  "padding-left: 20px;";

            var html = this.getStartElementHtml("div", {class: _class, style: _style,id: _id})
                + " ";

            if(switchCase.test === null) html += "default:
";
            else html += "case " + this.generateExpression(switchCase.test) + ":
";

            for(var i = 0; i < switchCase.consequent.length; i++)
            {
                html += this.generateHtml(switchCase.consequent[i]);
            }

            html += this.getEndElementHtml("div");

            return html;
        },

        generateFromTryStatement: function(tryStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.TryStatement  + " node" + this._generateHasBeenExecutedClass(tryStatement);
            var _id = "node" + this.formatId(tryStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class:"keyword"}, "try")
                + this.generateHtml(tryStatement.block);

            var handlers = tryStatement.handlers || (ValueTypeHelper.isArray(tryStatement.handler) ? tryStatement.handler : [tryStatement.handler]);
            // catch clauses
            for(var i = 0; i < handlers.length; i++)
            {
                html += this.generateFromCatchClause(handlers[i]);
            }

            if(tryStatement.finalizer != null)
            {
                html += this.getElementHtml("span", {class:"keyword"}, "finally")
                    + this.generateHtml(tryStatement.finalizer);
            }

            return html + this.getEndElementHtml("div");
        },

        generateFromLabeledStatement: function(labeledStatement)
        {
            var _class = ASTHelper.CONST.STATEMENT.LabeledStatement + " node" + this._generateHasBeenExecutedClass(labeledStatement);
            var _id = "node" + this.formatId(labeledStatement.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.generateFromIdentifier(labeledStatement.label) + ": "
                + this.generateHtml(labeledStatement.body)
                + this.getEndElementHtml("div");

            return html;
        },

        generateFromVariableDeclaration: function(variableDeclaration)
        {
            var html = "";

            var _class = ASTHelper.CONST.VariableDeclaration + " node" + this._generateHasBeenExecutedClass(variableDeclaration);
            var _id = "node" + this.formatId(variableDeclaration.nodeId);

            html += this.getStartElementHtml("span", {class: _class, id: _id});
            html += this.getElementHtml("span", {class:"keyword"}, variableDeclaration.kind);
            html += " ";

            for (var i = 0; i < variableDeclaration.declarations.length; i++)
            {
                var previousDeclarator = i == 0 ? variableDeclaration : variableDeclaration.declarations[i - 1];
                var currentDeclarator = variableDeclaration.declarations[i];

                if (previousDeclarator != variableDeclaration)
                {
                    html += ", ";
                }

                html += this.generateFromVariableDeclarator(currentDeclarator);
            }

            if (ASTHelper.isForStatement(variableDeclaration.parent) || ASTHelper.isForInStatement(variableDeclaration.parent))
            {
                html += this.getEndElementHtml("span");
            }
            else
            {
                html += ";" + this.getEndElementHtml("span") + "
";
            }

            return html;
        },

        generateFromVariableDeclarator: function(variableDeclarator)
        {
            var html = this.getStartElementHtml
            (
                "span",
                {
                    class: ASTHelper.CONST.VariableDeclarator,
                    id: "node" + this.formatId(variableDeclarator.nodeId)
                }
            );

            html += this.generateFromPattern(variableDeclarator.id);

            if(variableDeclarator.init != null)
            {
                html += " = ";
                html += this.generateHtml(variableDeclarator.init);
            }

            return html + this.getEndElementHtml("span");
        },

        generateFromPattern: function(pattern)
        {
            if(ASTHelper.isIdentifier(pattern)) { return this.generateFromIdentifier(pattern);}
        },

        generateFromCatchClause: function(catchClause)
        {
            var _class = ASTHelper.CONST.CatchClause + " node" + this._generateHasBeenExecutedClass(catchClause);
            var _id = "node" + this.formatId(catchClause.nodeId);

            var html = this.getStartElementHtml("div", {class: _class, id: _id})
                + this.getElementHtml("span", {class: "keyword"}, "catch");

            html += " (" + this.generateHtml(catchClause.param);

            if(catchClause.guard != null) html += " if " + this.generateExpression(catchClause.guard);

            html += ")";
            html += this.generateStatement(catchClause.body);

            html += this.getEndElementHtml("div");

            return html;
        },

        generateFromIdentifier: function(identifier)
        {
            var _class = ASTHelper.CONST.Identifier + " node";
            var _id = "node" + this.formatId(identifier.nodeId);
            //var _padding = this.getStyle(identifier);

            //, style: _padding
            return this.getElementHtml("span", {class: _class, id: _id}, identifier.name);
        },

        generateFromLiteral: function(literal)
        {
            if (ValueTypeHelper.isString(literal.value))
            {
                return this.getElementHtml
                (
                    "span",
                    { class: "String", id: "node" + this.formatId(literal.nodeId) },
                        literal.raw != null ? this.escapeHtml(literal.raw) : "\"" + this.escapeHtml(literal.value) + "\""
                );
            }
            else if (ValueTypeHelper.isBoolean(literal.value) || ValueTypeHelper.isNull(literal.value))
            {
                return this.getElementHtml("span", {class: "Keyword", id: "node" + this.formatId(literal.nodeId)}, literal.value);
            }
            else if(ValueTypeHelper.isInteger(literal.value))
            {
                return this.getElementHtml("span", {class: "Number", id: "node" + this.formatId(literal.nodeId)}, literal.value);
            }
            else if(ValueTypeHelper.isObject(literal.value))
            {
                var regExString = "";

                if(literal.value.constructor != null && literal.value.constructor.name === "RegExp")
                {
                    regExString = literal.value.toString();
                }
                else //over JSON conversion
                {
                    regExString = atob(literal.value.RegExpBase64);
                }

                regExString = ValueTypeHelper.adjustForRegExBug(literal.value, regExString);

                return this.getElementHtml("span", {class: "RegExp", id: "node" + this.formatId(literal.nodeId)}, regExString );
            }
            else
            {
                return this.getElementHtml("span", {class: ASTHelper.CONST.Literal, id: "node" + this.formatId(literal.nodeId)}, literal.value);
            }
        },

        getSequenceHtml: function(sequence)
        {
            var html = "";

            for(var i = 0; i < sequence.length; i++)
            {
                if(i != 0) { html += ", "; }
                html += this.generateHtml(sequence[i]);
            }

            return html;
        },

        getElementHtml: function(elementType, attributes, content)
        {
            return this.getStartElementHtml(elementType, attributes) + content + this.getEndElementHtml(elementType);
        },

        getStartElementHtml: function(elementType, attributes)
        {
            var html = "<" + elementType + " ";

            for(var propertyName in attributes)
            {
                html += propertyName + " = '" + attributes[propertyName] + "' ";
            }

            html += ">";

            return html;
        },

        getEndElementHtml: function(elementType)
        {
            return "</" + elementType  + ">";
        },

        getStyle: function(currentElement)
        {
            if( ASTHelper.isLoopStatement(currentElement.parent)
                || ASTHelper.isIfStatement(currentElement.parent)
                || ASTHelper.isSwitchCase(currentElement.parent))
            {
                return "padding-left: 20px";
            }

            if (currentElement.type == "ObjectExpression")
            {

            }

            return "";
        },

        _generateHasBeenExecutedClass: function(expression)
        {
            if(expression == null) { return ""; }

            return (expression.hasBeenExecuted ? " hasBeenExecuted "
                : " hasNotBeenExecuted ")
                + (expression.differsInExecution ? " differs " : "")
                + (expression.shouldBeIncluded ? " hasBeenIncluded" : "hasNotBeenIncluded");
        },

        formatId: function(currentId)
        {
            if(currentId < 0)
            {
                alert("Invalid Node Identification: ID cannot be negative.)");
            }
            if(currentId > 999999)
            {
                alert("Invalid Node Identification: ID exceeds, but is limited to,  6 characters");
            }
            return ("00000" + currentId).slice(-6);
        },

        escapeHtml: function(string)
        {
            return string.replace(/&/g, "&").replace(/>/g, ">").replace(/</g, "<").replace(/"/g, """).replace(/'/g, "'").replace(/\//, "/");
        },

        _LEFT_GULL_WING:  "{",
        _RIGHT_GULL_WING: "}",
        _LEFT_PARENTHESIS: "(",
        _RIGHT_PARENTHESIS: ")",
        _LEFT_BRACKET : "[",
        _RIGHT_BRACKET: "]",
        _SEMI_COLON: ";",
        _QUESTION_MARK: "?",
        _COLON: ":",
        _DOT: ".",
        _COMMA: ",",
        _IF_KEYWORD: "if",
        _ELSE_KEYWORD: "else",
        _FOR_KEYWORD: "for",
        _WHILE_KEYWORD: "while",
        _DO_KEYWORD: "do",
        _WITH_KEYWORD: "with",
        _IN_KEYWORD: "in",
        _FUNCTION_KEYWORD: "function",
        _BREAK_KEYWORD: "break",
        _CONTINUE_KEYWORD: "continue",
        _TRY_KEYWORD: "try",
        _CATCH_KEYWORD: "catch",
        _FINALLY_KEYWORD: "finally",
        _THROW_KEYWORD: "throw",
        _RETURN_KEYWORD: "return",
        _VAR_KEYWORD: "var",
        _SWITCH_KEYWORD: "switch",
        _CASE_KEYWORD: "case",
        _DEFAULT_KEYWORD: "default"
    }
})();

redpajama_set_name: RedPajamaGithub


askART Christopher Nevinson - Pricing Art - What's my art worth?
Christopher Richard Wynne (C.R.W.) Nevinson was active/lived in New York / United Kingdom, England. Christopher Nevinson is known for war-themed painting, modernist urban landscape.


To be successful at scale modeling it is important to study any available instructions first. Then you need to become familiar with all available parts and the assembly sequences spelled out in the plans or those you devise for scratch building.
But frequently, you need to take the serious edge off. Remember, the true nature of this hobby is creating scale models. This involves the use of your own abilities and then expanding their boundaries by using your imagination. This means have fun and a laugh even at our own expense.
1.	Built into every modeler's workbench is a black hole that swallows parts. Only on rare occasions will the modeler ever see that part again though he may hear it rattling through the vacuum cleaner.
a.	Only highly detailed scratch built parts or those with no replacement fall into this hole.
b.	The probability of dropping your most needed part is inversely proportional to the size of the part.
c.	The closer the color of your part matches the color of the carpet (that's right no sound will give away the location) the more likely you will drop it.
d.	Once dropped, your treasured part will bounce immediately to the most inaccessible area of the room covering a horizontal distance equal to the length of the drop multiplied by the time spent in searching.
e.	A dropped X-acto knife will always be point first and contrary to d., the blade point will find your foot. It will not bounce.
f.	The moment you cease your search for a dropped part, you will step on it.
2.	The amount of time it takes to build a kit is equal to the sum of the time spent in research plus the number of plan pages multiplied by the number of parts less the time it takes for the glue to dry.
a.	The more un-built kits you have on shelves, the fewer kits you will actually complete.
b.	Your un-built kits will expand inversely proportional to the tightness with which they are packed.
c.	Reference materials, magazines and plans will increase in volume inversely proportional to the available space.
3.	Regardless of your bench's dimensions in feet, your work space will be done in a five-inch square just inside the front lip.
4.	The minute you purchase a new $9 modeling tool, you will find it in the Dollar Store in a pack of three.
5.	Regardless of your method for sealing paint containers you will find it has dried out two days prior to its intended use.
6.	The amount you pay for a new paint brush is directly proportional to the number of weeks it will contain dried paint.
7.	All kit manufacturers are committed to an association directive to hold new releases until six months after they have been scratch built at least six times.
8.	The odds the paint will go in the wrong place are in direct proportion to the number of hours spent building what ever it is you're painting.
9.	The chances of the large part falling painted side down are directly proportional to the cost of the carpet.


Traditionally everything was done as a hierarchy. Decisions were pushed down from the top. What has happened in the 21st century, though, is that networks are displacing hierarchies. Fred Wilson brought this up in a blog post today and I thought it worth remembering.
Networks are replacing hierachies as we enter the information era.
I'm going to take a shot at defending this claim "Networks are replacing hierarchies as we enter the information era." People are mis-interpreting it, because of the word "replacing".
Maybe it's a long shot to say "replacing" now. But Networks are emerging in parallel to existing systems. They may not be replacing them, but they are growing alongside these incumbents, and gradually taking a bigger share, such they will become more dominant over time. Networks are emerging in new areas that didn't exist before.
So, Networks are making hierarchies less relevant, as we enter the information era.
My questions: How far can we push this? Can all systems and software be network-driven instead of hierarchical? Is the usage network or the software itself? What does network-driven software look like and can it be done for non-open source solutions? Does a focus on the network give that company an advantage over the hierarchically-oriented company? Are there places where hierarchy still wins? Can systems be both at the same time and, if so, how does an organization decide how much of each and when?


Very few people--except the willfully obtuse--fail to appreciate how important sound sexual harassment policies are in the workplace and public venues. The imperatives are financial as well as moral and constitutional. At the same time, human behavior and inclinations being what they are, it is impossible to eliminate the possibility of one person interpreting an action or remark as sexual harassment. As an employer, however, you are far better off understanding exactly what it is and how you can recognize it in the workplace.
What is sexual harassment, then? In the workplace, it amounts to an employee being treated unfairly because of their gender. This might be what is called quid pro quo harassment, which is--to take an example--when a promotion is offered (however informally) in exchange for a sexual favor or favors. Hostile work environment harassment is another typical form. Lewd behavior, unwelcome remarks, and pornographic images or objects are good examples.
A sexual harassment lawsuit can cause a company serious problems, financial settlements and dismissals aside. The damage done to corporate image and employee morale is generally very hard to reverse. The best way to offset such a possibility is to have a complete and strongly enforced sexual harassment policy both in place and well advertised within the company and to the public. Title VII of the federal Civil Rights Act of 1964 is the basis for sexual harassment law.
Traditionally, sexual harassment has been identified with physical behavior. Since the advent of the Internet and IT, however, it has found new form. Specifically, this refers to email, whether intranet or Internet. A rigorous computer security system and firewall are critical to forestalling--as much as it is possible--this avenue of sexual harassment.
In formulating a policy for your own company, you'll do well to look at sample generic policies available from business and legal service firms. Clearly, drafting a policy calls for a pool of management. Ideally, the team would comprise expert consultants and/or representatives from human resources, legal affairs, accounting, and IT departments.


We talk with Dan Carter who is running for Senator Blumenthal's seat. He is here to share his support for vapers rights.
Next post Rising From The Ashes: Episode 11 – We talk about some new and pressing issues and share some big news.


Jesus Rocks The Redwoods 2017 - Get Your FREE Tickets Today!
Mark your calendar for this Annual Christian Worship Festival. This year's event features many incredible Worship Bands, Vendors, Food & Beverages, Ministry Booths, Children Activities and a NEW Worship Workshop from 10am-12pm. Register for your FREE tickets by clicking on the event image next to this post.
The festival opens at 10am and ends at 9pm. Families, Children, Churches, Worship Teams and everyone is welcome.
Looking forward to a memorable event this year!


Laurent-Perrier's Ultra Brut is a "zero dosage" champagne, meaning that no sugar is added at the end of the fermentation process. It might surprise you to learn that this is unusual, but it is.
Does it mean that Ultra Brut's a zero calorie, guilt free way of consuming the world's favourite celebratory tipple. Hmm, probably not.
On the other hand does it mean that it's a super dry, super crisp, superstylish, just plain super glass of fizz? It certainly does. Ultra, indeed.
Laurent Perrier's Ultra Brut is a "zero dosage" champagne, meaning that no sugar is added at the end of the fermentation process. It might surprise you to learn that this is unusual, but it is. Does it mean that Ultra Brut's a zero calorie, guilt free way of consuming the world's favourite celebratory tipple. Hmm, probably not. On the other hand does it mean that it's a super dry, super crisp, superstylish, just plain super glass of fizz? It certainly does. Ultra, indeed.


Our Data Protection Officer can answer any questions in connection with and related to our data protection as well as concerning any of our data saved by us.
All the texts, images and graphics as well as sound, video and animation files on the Insiders Technologies GmbH website and their layout are protected by copyright and/or other property rights. Any use requires express written permission from Insiders Technologies GmbH.
We are only liable for our own content as per the general legal provisions. We do not accept liability with respect to the data and information provided on our website being up-to-date, correct or complete, nor for its quality.
Content from other providers that is referred to on our website by means of direct or indirect links does not reflect the opinion of Insiders Technologies GmbH. We are not responsible for content from other providers. At the time the link was set up, there were no legal objections to the linked sites. We would like to ask for appropriate notification should this change.


Provides insufficient funding for the Title X Family Planning Program (at $286.5 million), while continuing regulatory efforts to fundamentally damage the program. Experts recommend the program receive at least $400 million in FY 2020.
Eliminates the evidence-based Teen Pregnancy Prevention (TPP) Program in Fiscal Year 2020. Currently funded at $101 million, the TPP Program funds 81 competitive five-year grants in a wide variety of communities and settings across the country, using evidence-based approaches.
Cuts the Title V Maternal and Child Health Block Grant by $17 million, from $678 million in fiscal year 2019 to a proposed level of $661 million for Fiscal Year 2020, despite increases in maternal mortality in the U.S.
Eliminates the Pregnancy Assistance Fund that provides competitive grants to states, tribes and territories to support pregnant and parenting teens and women, and combat violence against pregnant women.
"The President's budget proposal will hurt young people and women across the country because it restricts access to proven public health and health care programs that support their power to decide if, when and under what circumstances to get pregnant and have a child. This budget proposal, if implemented, could reverse the historic progress the country has made in improving access to information and care. In addition, programs that are focused on improving the health and well-being of expectant mothers, children and their families may not be there for them.
Power to Decide is pleased though to see the proposed one-year reauthorization of the Personal Responsibility Education Program (PREP) at $75 million, but states ultimately need a multi-year reauthorization in order to plan and serve young people. PREP provides funding to states, communities and tribes to make evidence-based sexual health education accessible to young people. In addition, while Power to Decide is pleased to see the Title X Family Planning Program funded, the amount is far less than the need. At the same time, the Administration has released its final "domestic gag rule." If implemented, the rule would have devastating consequences for the Title X Program and low-income women's access to high-quality contraceptive care as well as information about and referrals for abortion care.


In the dental profession, as in all sciences, new techniques and methods continue to emerge. Our commitment to you is to keep you abreast of the progress the highest degree of professional skill and ability.
Our philosophy is to first understand your needs and demands, then fully examine and diagnose your condition and educate you as to the appropriate course of action for your specific situation. We strive to do this in an office setting that is both pleasant and friendly, as well as having the highest level of cleanliness and patient protection.
Establishing a lasting relationship with our patients is based upon mutual trust and open communication. We invite you questions anytime and value any suggestions you may have.


J Plumbing Ltd. Has Been Proudly Family Owned and Operated For Over 40 Years.
Our drain machines can snake out up to 150 ft.
Owner Dave Milne and the experienced team at J Plumbing Ltd., happily provide residential and commercial plumbing services to Simcoe County. Family owned and operated for over 40 years. Established in Barrie Ontario, J Plumbing Ltd. has more than 75 years' combined plumbing experience.
© J Plumbing | MediaSuite Inc.


text:
OPW Heritage Links
Tickets and Times
The Terrace Café
Viking Excavation
Medieval Tower
State Apartments (Online Tour)
Chapel Royal
Citizens Curate
Dementia Friendly
Dinners and Receptions
Undiscovered Spaces
The Events Team
The Birth of Modernism in Irish Art 1920 – 1960
Dublin Castle Exhibitions
By David Britton, Curator of 'The Birth of Modernism in Irish Art 1920 – 1960'
Isolated on the Western fringes of Europe it took time for the influence of early 20th century European developments in art to reach these shores. This exhibition explores the development of modernism in Ireland beginning in 1920, a period of political turmoil in this country and ends in the modern Ireland of 1960. It contrasts the traditional 'Irish School of painting' of the Royal Hibernian Academy (RHA) favoured by de Valera and the new Irish Government versus the European influenced art that was being championed, mainly by women artists such as Mainie Jellett, Evie Hone and Norah McGuinness through the Society of Dublin Painters and the Irish Exhibitions of Living Art (IELA).
This exhibition gives the public a unique opportunity to view paintings and sculptures that have been drawn exclusively from private Irish collections and thus not normally accessible to the public. Works such as Jack B. Yeats 'We are leaving now' (1928) is being exhibited in Dublin for the first time in over 50 years.
Jack Butler Yeats, We are leaving you now (1928)
Before one gets distracted by the paintings in the exhibition we recommend, on entering the first room, the 'Minerva room', that you look up to admire the fine plasterwork ceiling by the stuccodore Bartholomew Cramillion done for Mespil House c1758. It appropriately depicts Minerva introducing the arts to Ireland. The ceiling was saved when Mespil House was demolished in the 1950's and moved to Dublin Castle. From 1911 until her death in 1943 Mespil House was the home of the painter Sarah Purser who hosted her famous 'first Tuesdays' the most notable 'Salon' in Dublin where writers, politicians and artists of every shade of opinion met to discuss the affairs of the day on the 2nd Tuesday of every month. Many of the artists now hanging in this room would have attended these 'Salons' and would most likely have seen this ceiling at Mespil House.
The exhibition opens with a group of paintings showing the influence of France in the development of Irish art. Roderic O'Conor is considered the only true Irish Impressionist arriving in Paris in 1886, he became a close friend of the painter Paul Gauguin amongst other French impressionists. Mary Swanzy, studied and exhibited at the 'Salon des Indépendants' in Paris as early as 1914. She was a founder member of the Society of Dublin Painters in 1920 along with Jack B. Yeats, Paul and Grace Henry and Letitia Hamilton.
Mainie Jellett, Composition (c. 1922)
When Mainie Jellett first exhibited her pure abstract work in 1923 in a group exhibition at the Dublin Painters Gallery it resulted in a hostile review by the artist/poet George (AE) Russell which caused much public debate in the letter pages of the national newspapers. Jellett in particular became an enthusiastic champion of modernism in Ireland and she encouraged and supported many emerging artists through her writing, lectures and her involvement with the Society of Dublin Painters and being a founding member of the IELA in 1943.
With the formation of The Free State in 1922 there was a desire to shape a new national identity to distinguish Ireland from Great Britain which in art terms meant looking inwards and to the past. The government and the newly emergent Catholic middle-classes were nationalistic but also very conservative culturally and thus they favoured social realist works of cottages in the west of Ireland or works depicting Irish peasants at work. These works were the main staple of the annual, male dominated, Royal Hibernian Academy exhibitions in this period.
Charles Lamb, Hearing the news (c. 1922)
Some of the RHA members who had studied abroad such as Paul Henry and Charles Lamb were involved in the early days of the Society of Dublin Painters but by the late 1920's this Society became dominated by women artists, many of whom had an Anglo-Irish background and their exhibitions became synonymous with the best of avant-garde painting in Ireland. Their dominance remained until the early 1940's and the arrival of The White Stag Group and the formation of the IELA in 1943.
Letitia M. Hamilton, A fair day Clifden
The main exponents of surrealism in Irish art were Colin Middleton whose 'The Bride' executed in 1938 is a good example of this genre and Nevill Johnson's apocalyptic post -war vision in 'Year of Grace' (1945). The 1940's saw the arrival of Basil Rákóczi and Kenneth Hall in Dublin where they formed, along with various other foreign artists escaping the war, the 'White Stag Group' which flourished between 1940 – 1945. They had a non-academic approach to painting with dynamic new ideas that influenced a generation of young Irish artists, such as Patrick Scott, Thurloe Conolly and Gerard Dillon.
In 1943 Mainie Jellett was instrumental along with Louis le Brocquy, Norah McGuinness, Jack Hanlon and others in organizing the first IELA exhibition which was established as a counterpoint to the perceived conservatism and stagnation of the RHA. By the end of the 1940's the IELA became dominated by a group of artists from Northern Ireland which included Daniel O'Neill, Gerard Dillon, George Campbell and Colin Middleton who exhibited both here in Dublin and abroad to critical acclaim.
Although born in Scotland William Scott grew up in Enniskillen in Northern Ireland getting his first art lessons from local teacher Kathleen Bridle followed by study at the Belfast College of Art. He became one of the most international of all post-war Irish artists and is represented here by an important early work 'Lemon and Funnel' (1949).
Norah McGuinness, The first sheaf
Norah McGuinness was involved in all aspects of Irish art in the period, 1920 until her death in 1980, encouraging many young Irish artists. She, along with Nano Reid represented Ireland at the Venice Biennale 1950, which was the first time the country had exhibited and it is interesting that the committee choose two female modernist Irish artists to represent the new Irish Republic (1948) on this world stage. Nano Reid had developed her own very individualistic style much influenced by the ancient monuments along the Boyne valley near her home town of Drogheda.
The exhibition 'The Birth of Modernism in Irish Art 1920 – 1960' is open every day 9.45am to 5.15pm in the State Apartments Galleries until August 18, 2019. Admission price: €3
Dublin Castle,
Dame St,
dublincastle@opw.ie
Venue Hire and Events
dublincastleevents@opw.ie
© The Office of Public Works

redpajama_set_name: RedPajamaCommonCrawl


Street Plans was hired by the City of Jersey City to plan and implement six walkability workshops as a subconsultant to Fitzgerald & Halliday Inc. The workshops consisted of temporary curb extensions, including a public-feedback board, tables and chairs, wayfinding signage, planters, and colorful paint. The workshops gathered feedback from residents to inform the City of Jersey City's forthcoming Pedestrian Enhancement Plan. Click here for more.
Biscayne Green was a three-week transformation of two parking medians along Biscayne Boulevard in Downtown Miami, FL. One parking median became a new pedestrian plaza, programmed with dance, music, and vendor events, while the other was comprised of a new playground, dog park, lawn, and seating terrace. The pilot project also included a dedicated bus and bike lane, and a new on-street parallel parking lane. Click here for more.
On January 24th, Street Plans implemented a day-long intervention along the waterfront in Downtown West Palm Beach. The project measured participants' neurological responses to experiencing the pop-up space. The data will help reveal the possible wellness benefits of well-designed urban spaces, and inform how urban design affects the minds and bodies of those who move throughout it. Click here for more.
Street Plans, together with Alta Planning + Design, designed and implemented 11 Tactical Urbanism projects as a part of the Southern California Association of Government's (SCAG) 2017 Go Human region-wide safety and encouragement campaign. Click HERE for more.
With financial support from the Walton Family Foundation and in partnership with the Bicycle Coalition of the Ozarks, Street Plans was hired by the Northwest Arkansas Regional Planning Commission to work with the cities of Bentonville, Bella Vista, and Rogers to create a series of month-long bikeway pilot projects. Click here for more.
Street Plans joined the City of San Marcos and Dover, Kohl & Partners in re-envisioning downtown utilizing tactical urbanism, which included a temporary two-way lane conversion, a temporary two-way cycle track, a farmer's market, and "pop-up" parks. This, along with a charrette, helped kick-off and inform the creation of a new form-based code. Click here for more.
The Greenbelt Alliance hired Street Plans to lead two Tactical Urbanism Demonstration Projects in the West San Carlos and South Bascom Urban Villages of San Jose. The first project was a two day demonstration project to improve bike infrastructure along Scott Street. The following project was a temporary "makeover" of a long-neglected alley. Click here for more.
On Friday, October 7th, Street Plans worked with local volunteers and Sam Schwartz Engineering to re-imagine Market Street in Poughkeepsie, NY 's downtown core for one day. The project used temporary materials to experiment with traffic calming strategies, and reclaim space in the right-of-way for gathering. Click HERE for more.
Together with PS21 (a local advocacy group), the City of Portsmouth, and many volunteers, Street Plans guided an effort to temporarily transform a block of Islington Street for four days. The goal was to show Portsmouth the change that is possible on their streets, increase civic engagement, and improve the safety and walkability of the area. Click here for more.
100 Resilient Cities partnered with Street Plans for the provision of "Tactical Resilience" workshops to the member cities of 100RC. The first of the three of these workshops was held in Norfolk, VA. The participants and workshop leaders installed four rain barrels, one rain garden, and depaved a sidewalk for landscaping/water retention. Click here for more.
Monterey Road is a walkable commercial corridor in downtown Morgan Hill. As part of a Complete Streets redesign of the roadway, Street Plans worked with Alta Planning + Design and the Morgan Hill Downtown Association to produce a weekend-long demonstration project that illustrated the two potential alternatives - one on each side of the street. Click here for more.
The Atlanta Regional Commission (ARC) hired Street Plans to lead a demonstration project that temporarily transformed 3 blocks of Auburn Avenue in Atlanta's Historic Old 4th Ward neighborhood into a model Lifelong Community – a healthy, walkable place with housing, transportation and service options for people of all ages. Click here for more.
Together with DuBois & King, Streets Plans is leading Plan BTV Walk Bike - the citywide bike and pedestrian master plan for Burlington, VT. As part of the project, Street Plans worked with local stakeholders to create Tactical Urbanism "demonstration projects" that illustrated possibilities for better bike and pedestrian infrastructure. Click here for more.
Street Plans worked with the Sydney-based consultancy Place Partners to integrate Tactical Urbanism into the implementation process for the High Street Master Plan. The goal was to work with businesses and community members to quickly design and deliver a temporary public park that would be in place for a one year trial period. Click here for more.
Street Plans was retained by the City of Somerville to assist with public outreach, transportation, street design, public space planning, and the integrations of Tactical Urbanism elements for the Davis Square and East Somerville neighborhood plans. Click HERE for more.
Bayfront Parkway was a one-week "living rendering" designed and organized by Street Plans that converted a median parking lot along Biscayne Boulevard into a pop-up park. Click HERE to see more. To see the next iteration of this project, see the Biscayne Green project page on our website.
Street Plans Principal, Tony Garcia, is the co-founder and former chairman of the board for Friends of Ludlam Trail, a grassroots campaign seeking to transform an abandoned railroad into a linear park/trail. A formal charrette process led to a compromise for 75% of the corridor to be preserved for green space with a bicycle and pedestrian trail, and 25% of the land would be dedicated to mixed-use development. Click here for more.
Street Plans led a Tactical Urbanism workshop aimed at five challenge sites found throughout Hamilton, Ontario. Workshop attendees developed and tested low-cost interventions at the five sites. The City of Hamilton initially pushed back, but within 6 months of the workshop more than 65 intersections, and now more than 100, had received city-installed pilot improvements, including the initial Locke/Herkimer Street intersection, which now has permanent infrastructure. Click here for more.
The Tactical Urbanism Salon travels to different cities to highlight and draw together individuals, organizations, and local government departments seeking new ways to overcome existing challenges in the built environment. Click HERE for more.
Street Plans worked with the Minneapolis-based organizations Wetland Habitat Restoration (WHR) and Juxtaposition Arts to lead visioning and design of a 6-month pilot project, which resulted in a 5-block demonstration of possibilities for a permanent greenway. Click here for more.


Whether you're dancing, lifting, or in downward dog, these stirrup leggings will be your go to.
Stripe elastic waist band sits comfortably at the hip and meet in a v-shape for a flattering fit.
with a stirrup foot which can be worn hooked over the foot or not for a full length option.


text:
Home / Oregon / Rogue Valley Youth Correctional Facility
Rogue Valley Youth Correctional Facility Inmate Search and Prison Information
Updated on: October 30, 2022
2001 NE F Street, Grants Pass, OR, 97526-4813
Rogue Valley Youth Correctional Facility inmate search: Jail Roster, Booking Date, Document Type, Address, Code, Charges, Detainer Information, Warrant #, Warrant No, Who's in jail, Alias, Release Date, Arrests, Facility, Statute, Degree Level, Case Number, Bookings, Institution, Mugshots, Bond, Case Description, Charge, Issuing Auth.
The Rogue Valley Youth Correctional Facility is situated in Grants Pass, Oregon. The Rogue Valley Youth Correctional Facility is an operated under the Oregon Department of Corrections as a multi-custody facility.
The Rogue Valley Youth Correctional Facility can house up to 100 male inmates within their main campus.
As a multi-custody facility, the Rogue Valley Youth Correctional Facility will house offenders from the G1 all the way up to the G4 custody level.
You should not that the Rogue Valley Youth Correctional Facility is broken up into two dormitory-style housing units, which can house over 100 inmates in each unit. They have over 935 double and single bunk bed cells.
The Rogue Valley Youth Correctional Facility has work assignments for inmates that consist of the following:
Raising Swine
Brook & Mop Factory
Managing Bulls
Farming Edible Crops
All Offenders will have access to health, dental, and medical services as well as educational programs, and vocational training.
Rogue Valley Youth Correctional Facility — General Information
Rogue Valley Youth Correctional Facility, State Prison.
Juvenile, Capacity 100 persons.
http://www.oregon.gov/oya/pages/facilities/rogue.aspx
How to Find Someone in Rogue Valley Youth Correctional Facility
Since the Rogue Valley Youth Correctional Facility is operated under the Oregon Department of Corrections, they have a BIG inmate roster available directly on the Oregon Department of Corrections website.
The inmate roster can be searched with the following pieces of information:
Inmate's Full Name
DC Number
Sending and receiving mail is one of the offenders few luxuries while they are serving out their time in the Rogue Valley Youth Correctional Facility. Remember that all incoming and outgoing mail will be checked by an employee of the Rogue Valley Youth Correctional Facility to ensure it is safe and free from contraband.
You will need to address your letter as follows:
Inmate Name, ID Number
Rogue Valley Youth Correctional Facility
Inmates in the Rogue Valley Youth Correctional Facility will need money to purchase extra items from the facilities commissary. These items typically include extra food such as snacks and beverages, clothing, entertainment items, and hygiene products.
Friends and family members of the offender can send money through JPay. JPay is a service that the Rogue Valley Youth Correctional Facility utilizes that allows you to easily put money on the offender's account. You should know that there will be a fee associated with this service.
To receive calls from an offender in the Rogue Valley Youth Correctional Facility, you will need to register your mobile phone number and your landline phone number with Securus Technologies using the provided links.
Offenders will be able to call you between the hours of 7 am to 10 pm. Keep in mind this time can change at a moment's notice. Typically, offenders will not be permitted to use the phones during their counts or when the facility is under lockdown.
At the Rogue Valley Youth Correctional Facility, offenders will be permitted to have visitors only on Saturdays and Sundays. Visitors are welcome to stop by for a visit between the hours of 8 am to 5 pm.
All visits will be for in two-hour duration depending on the classification the inmate has and whether the visit will be no-contact or contact visit.
Visitors will only be permitted to bring in a Ziploc bag with $20 in quarter, which they can use at the vending machine located in the visitation room.
Josephine County Jail
Josephine County Juvenile Detention Center
Rogue River City Jail
Jackson County Juvenile Detention Center
Eagle Point City Jail
Jackson County Jail
Talent City Jail
Butte Falls City Jail
Bar-O Boys Ranch
Winston City Jail
Powers City Jail
Douglas County Jail
Douglas County Juvenile Detention Center
Roseburg City Jail
Curry County Jail
Brookings City Jail
Gold Beach City Jail
Pelican Bay State Prison
Myrtle Creek City Jail
Other Types of Correctional Facilities in Oregon
City Jail 98
County Jail 54


Home » Magazine » National » Hardik Patel, Alpesh Thakor, Jignesh Mevani: Three (Ex-) Musketeers?
Bhavna Vij-Aurora	March 14, 2019 00:00 IST Hardik Patel, Alpesh Thakor, Jignesh Mevani: Three (Ex-) Musketeers?
Three young activists—Hardik Patel, Alpesh Thakor and Jignesh Mevani—had grabbed a fair bit of spotlight before, during and after the Gujarat assembly polls over a year ago, with their oppositional politics creating ripples even beyond the boundaries of their state. Thakor's appeal may have been restricted to the large OBC segment in Gujarat. But Hardik, as the young spearhead of the Patel agitation, was seen as an iconic face for restive middle castes all over. And Mevani, as an articulate Dalit voice, was creating a kind of national imprint for himself.
But a lot of those swept up by their rhetoric are a disillusioned lot now—with perhaps the exception of Mevani. Both Hardik and Thakor, 43, are seen as deserters to the cause they once espoused. Owing to their mass appeal, they were all wooed by parties. Thakor, who had founded the OBC-SC- ST Ekta Manch, joined the Congress before the 2017 Gujarat polls and won from Radhanpur. But recently, the maverick leader kept the Congress on tenterhooks and openly negotiated with the BJP, admitting he wants to be a minister.
The bigger eclipse in popularity may belong to Hardik, who is 25 now. Too young to contest in 2017, he had kept up a thin veneer of being independent, only consorting discreetly with the Congress. But he has now fallen to the lure of a GOP ticket, and has signed on, trotting out the usual lines about abiding by the party's decision if "it decides to field me in electoral politics." Hardik had taken up cudgels on behalf of the Patidar community in 2015, demanding its inclusion in the OBC list, drawing huge crowds with his forceful oratory. The Patidars now say he has abandoned them in favour of a luxurious lifestyle, and moves around in a big car while their lot stays unchanged.
Mevani, 36, rose into prominence as he led the post-Una agitation in 2016. He successfully contested the assembly polls from Vadgam as an independent supported by Congress and AAP. The young Ambedkarite has desisted from joining a political party but the CPI's national headquarters Ajoy Bhavan is his preferred address when he visits the Capital.