<?php
// Exit if accessed directly
if ( !defined( 'ABSPATH' ) ) exit;

/*
    Class: ChildThemeConfiguratorCSS
    Plugin URI: http://www.childthemeconfigurator.com/
    Description: Handles all CSS input, output, parsing, normalization and storage
    Version: 2.5.6
    Author: Lilaea Media
    Author URI: http://www.lilaeamedia.com/
    Text Domain: chld_thm_cfg
    Domain Path: /lang
    License: GPLv2
    Copyright (C) 2014-2018 Lilaea Media
*/

class ChildThemeConfiguratorCSS {
    
    // data dictionaries
    var $dict_query;        // @media queries and 'base'
    var $dict_sel;          // selectors  
    var $dict_qs;           // query/selector lookup
    var $dict_rule;         // css rules
    var $dict_val;          // css values
    var $dict_seq;          // child load order (priority)
    var $dict_token;
    // hierarchies
    var $val_ndx;           // selector => rule => value hierarchy
    // key counters
    var $qskey;             // counter for dict_qs
    var $querykey;          // counter for dict_query
    var $selkey;            // counter for dict_sel
    var $rulekey;           // counter for dict_rule
    var $valkey;            // counter for dict_val
    var $tokenkey;          // counter for dict_token

    // from parent/child form
    var $child;             // child theme slug
    var $parnt;             // parent theme slug
    var $configtype;        // legacy plugin slug
    var $handling;          // child stylesheet handling option
    var $enqueue;           // whether or not to load parent theme
    var $ignoreparnt;       // no not parse or enqueue parent
    var $qpriority;
    var $mpriority;
    var $hasstyles;
    var $parntloaded;
    var $childloaded;
    var $parnt_deps;        // 
    var $child_deps;        //
    var $forcedep;
    var $swappath;
    var $addl_css;
    var $cssunreg;
    var $csswphead;
    var $cssnotheme;
    var $reorder;

    // header settings
    var $child_name;        // child theme name
    var $child_author;      // child theme author
    var $child_authoruri;   // child theme author website
    var $child_themeuri;    // child theme website
    var $child_descr;       // child theme description
    var $child_tags;        // child theme tags
    var $child_version;     // stylesheet version
    
    // miscellaneous properties
    var $fsize;             // used to check if styles changed since last update
    var $converted;         // @imports coverted to <link>?
    var $version;           // version of last saved data
    var $templates;         // cache of parent template files
    var $imports;           // @import rules
    var $recent;            // history of edited styles
    var $max_sel;
    var $memory;
    var $styles;            // temporary update cache
    var $temparray;
    var $instances = array();
    var $vendorrule = array(
        'box\-sizing',
        'font\-smoothing',
        'border(\-(top|right|bottom|left))*\-radius',
        'box\-shadow',
        'transition',
        'transition\-property',
        'transition\-duration',
        'transition\-timing\-function',
        'transition\-delay',
        'hyphens',
        'transform',
        'columns',
        'column\-gap',
        'column\-count',
    );
    var $configvars = array(
        'addl_css',
        'forcedep',
        'swappath',
        'cssunreg',
        'csswphead',
        'cssnotheme',
        'reorder',
        'parnt_deps',
        'child_deps',
        'hasstyles',
        'parntloaded',
        'childloaded',
        'ignoreparnt',
        'qpriority',
        'mpriority',
        'enqueue',
        'handling',
        'templates',
        'max_sel',
        'imports',
        'child_version',
        'child_author',
        'child_name',
        'child_themeuri',
        'child_authoruri',
        'child_descr',
        'child_tags',
        'parnt',
        'child',
        'configtype', // legacy support
        'valkey',
        'rulekey',
        'qskey',
        'selkey',
        'querykey',
        'tokenkey',
        'recent',
        'converted',
        'fsize',
        'version',
    );
    var $dicts = array(
        'dict_qs'               => 0,
        'dict_sel'              => 0,
        'dict_query'            => 0,
        'dict_rule'             => 0,
        'dict_val'              => 0,
        'dict_seq'              => 0,
        'dict_token'            => 0,
        'val_ndx'               => 0,
    );
    var $packer; // packer object
    
    function __construct() {
        $this->mem_chk();
        // scalars
        $this->querykey         = 0;
        $this->selkey           = 0;
        $this->qskey            = 0;
        $this->rulekey          = 0;
        $this->valkey           = 0;
        $this->max_sel          = 0;

        $this->child_name       = '';
        $this->child_author     = 'Child Theme Configurator';
        $this->child_themeuri   = '';
        $this->child_authoruri  = '';
        $this->child_descr      = '';
        $this->child_tags       = '';
        $this->child_version    = '1.0';
        
        $this->configtype       = 'theme'; // legacy support
        $this->child            = '';
        $this->parnt            = '';
        $this->ignoreparnt      = 0;
        $this->qpriority        = 10;
        $this->mpriority        = 10;
        $this->version          = '2.5.6';
        
        // do not set enqueue, not being set is used to flag old versions

        // multi-dim arrays
        $this->templates        = array();
        $this->imports          = array( 'child' => array(), 'parnt' => array() );

        $this->recent           = array();
        $this->packer           = new ChildThemeConfiguratorPacker();
    }
    
    // helper function to globalize ctc object
    function ctc() {
        return ChildThemeConfigurator::ctc();
    }
    
    function mem_chk() {
        $currmemory = $this->memory;
		if ( function_exists( 'memory_get_peak_usage' ) ) {
			$usage      = memory_get_peak_usage();
		} else {
			$usage      = memory_get_usage();
		}
        $this->memory = $usage;
        $usage -= $currmemory;
        return number_format( $this->memory / ( 1024 * 1024 ), 2 ) . ' MB diff ' . number_format( $usage / 1024, 2 ) . ' kB';
    }
    
    // loads current ctc config data 
    function load_config( $key = NULL ) {
        //list(, $callerarr) = debug_backtrace(false);
        //$caller = ( isset( $callerarr[ 'class' ] ) ? $callerarr[ 'class' ] . '::' : '' ) . $callerarr[ 'function' ];
        if ( $key && isset( $this->dicts[ $key ] ) ):
            $option = CHLD_THM_CFG_OPTIONS . apply_filters( 'chld_thm_cfg_option', '' );
            if ( !$this->dicts[ $key ] ): // dict not loaded yet
                //$this->ctc()->debug( 'memory before load: ' . $this->mem_chk(), __FUNCTION__, __CLASS__ );
                //$this->ctc()->debug( $option . '_' . $key . ' -- called from ' . $caller, __FUNCTION__, __CLASS__ );
                // 
                if ( !$this->ctc()->is_new && ( $config = get_site_option( $option . '_' . $key ) ) ): 
                    $this->{ $key } = $config; // if not new child theme and option exists, load it
                else:
                    $this->{ $key } = array(); // otherwise load empty array 
                endif;
            
                $this->dicts[ $key ] = 1; // flag as loaded
                //$this->ctc()->debug( 'memory after load: ' . $this->mem_chk(), __FUNCTION__, __CLASS__ );
            else:
                //$this->ctc()->debug( $key . ' already loaded -- called from ' . $caller, __FUNCTION__, __CLASS__ );
            endif;
        endif;
        // initial setup
        if ( empty( $key ) && !isset( $this->enqueue ) ):
            $option = CHLD_THM_CFG_OPTIONS . apply_filters( 'chld_thm_cfg_option', '' );
            //$this->ctc()->debug( 'loading option: ' . $option . '_' . ( $key ? $key : 'configvars' ) 
            //    . ' -- called from ' . $caller, __FUNCTION__, __CLASS__ );
            if ( ( $configarray = get_site_option( $option . '_configvars' ) ) && count( $configarray ) ):
                foreach ( $this->configvars as $configkey ):
                    if ( isset( $configarray[ $configkey ] ) )
                        $this->{$configkey} = $configarray[ $configkey ];
                endforeach;
                // convert dictionaries from < 2.1.0
                if ( empty( $configarray[ 'version' ] ) || version_compare( $configarray[ 'version' ], '2.1.0', '<' ) ):
                    $this->convert_dict_arrays();
                else:
                    $this->ctc()->debug( 'dict format up to date', __FUNCTION__, __CLASS__ );
                endif;
            else:
                return FALSE;
            endif;
        endif;
        
    }
    
    // writes ctc config data to options api
    function save_config( $override = NULL ) {
        // set latest stylesheet size
        $this->get_stylesheet_path();
        global $wpdb;
        if ( isset( $override ) ) $option = $override;
        else $option = apply_filters( 'chld_thm_cfg_option', '' );
        $option = CHLD_THM_CFG_OPTIONS . $option;
        $configarray = array();
        foreach ( $this->configvars as $configkey )
            $configarray[ $configkey ] = empty( $this->{$configkey} ) ? NULL : $this->{ $configkey };
            //$this->ctc()->debug(  'saving option: ' . $option . '_configvars', __FUNCTION__, __CLASS__ );
        if ( is_multisite() ):
            update_site_option( $option . '_configvars', $configarray ); 
        else:
            // do not autoload ( passing false above only works if value changes
            update_option( $option . '_configvars', $configarray, FALSE ); 
        endif;
        
        foreach ( $this->dicts as $configkey => $loaded ):
            if ( $loaded ): // only save if dict is loaded
                //$this->ctc()->debug(  'saving option: ' . $option . '_' . $configkey, __FUNCTION__, __CLASS__ );
                if ( is_multisite() ):
                    update_site_option( $option . '_' . $configkey, $this->{$configkey} ); 
                else:
                    // do not autoload ( passing false for update_site_option only works if value changes )
                    update_option( $option . '_' . $configkey, $this->{$configkey}, FALSE );
                endif;
            endif;
        endforeach;
        
    }
        
    /**
     * determine effective stylesheet path and measure size
     */
    function get_stylesheet_path() {
        $stylesheet = apply_filters( 'chld_thm_cfg_target', $this->get_child_target( $this->ctc()->get_child_stylesheet() ), $this );
        $this->fsize = filesize( $stylesheet );
        $this->ctc()->debug( 'updated file size: ' . $this->fsize, __FUNCTION__, __CLASS__ );
        return $stylesheet;
    }
    /**
     * get_prop
     * Getter interface (data sliced different ways depending on objname )
     */
    function get_prop( $property, $params = NULL ) {
        switch ( $property ):
            case 'fsize':
                return empty( $this->fsize ) ? FALSE : $this->fsize;
            case 'converted':
                return !empty( $this->converted );
            case 'max_sel':
                return empty( $this->max_sel ) ? FALSE : $this->max_sel;
            case 'imports':
                
                return $this->obj_to_utf8( !empty( $this->imports[ 'child' ] ) && is_array( $this->imports[ 'child' ] ) ? 
                    ( current( $this->imports[ 'child' ] ) == 1 ? 
                        array_keys( $this->imports[ 'child' ] ) : 
                            array_keys( array_flip( $this->imports[ 'child' ] ) ) ) : 
                                array() );
            case 'queries':
                return $this->obj_to_utf8( $this->denorm_dict_qs() );
            case 'selectors':
                return empty( $params[ 'key' ] ) ? 
                    array() : $this->obj_to_utf8( $this->denorm_dict_qs( $params[ 'key' ] ) );
            case 'rule_val':
                return empty( $params[ 'key' ] ) ? array() : $this->denorm_rule_val( $params[ 'key' ] );
            case 'val_qry':
                if ( isset( $params[ 'rule' ] ) ):
                    return empty( $params[ 'key' ] ) ? 
                        array() : $this->denorm_val_query( $params[ 'key' ], $params[ 'rule' ] );
                endif;
            case 'qsid':
                return empty( $params[ 'key' ] ) ? 
                    array() : $this->obj_to_utf8( $this->denorm_sel_val( $params[ 'key' ] ) );
            case 'rules':
                $this->load_config( 'dict_rule' );
                asort( $this->dict_rule );
                //ksort( $this->dict_rule );
                //return $this->obj_to_utf8( $this->dict_rule );
                /** lookup ** -- need to flip array??? */
                return $this->obj_to_utf8( array_flip( $this->dict_rule ) );
            case 'child':
                return $this->child;
            case 'parnt':
                return $this->parnt;
            case 'configtype': // legacy plugin extension support
                return $this->configtype;
            case 'enqueue':
                return empty( $this->enqueue ) ? FALSE : $this->enqueue;
            case 'addl_css':
                return empty( $this->addl_css ) ? array() : $this->addl_css;
            case 'parnt_imp':
                return empty( $this->parnt_imp ) ? array() : $this->parnt_imp;
            case 'forcedep': // v2.1.3
                return empty( $this->forcedep ) ? array() : array_keys( $this->forcedep );
            case 'swappath': // v2.3.1
                return empty( $this->swappath ) ? array() : (array) $this->swappath;
            case 'parnt_deps':
                return empty( $this->parnt_deps ) ? array() : $this->quotify_dependencies( 'parnt_deps' );
            case 'child_deps':
                return empty( $this->child_deps ) ? array() :  $this->quotify_dependencies( 'child_deps' );
            case 'templates':
                return empty( $this->templates )  ? FALSE : $this->templates;
            case 'ignoreparnt':
                return empty( $this->ignoreparnt ) ? 0 : 1;
            case 'qpriority':
                return empty( $this->qpriority ) ? 10 : $this->qpriority;
            case 'mpriority':
                return empty( $this->mpriority ) ? 10 : $this->mpriority;
            case 'parntloaded':
                return empty( $this->parntloaded ) ? FALSE : $this->parntloaded;
            case 'childloaded':
                return empty( $this->childloaded ) ? FALSE : $this->childloaded;
            case 'hasstyles':
                return empty( $this->hasstyles ) ? 0 : 1;
            case 'cssunreg':
                return empty( $this->cssunreg ) ? 0 : 1;
            case 'csswphead':
                return empty( $this->csswphead ) ? 0 : 1;
            case 'cssnotheme':
                return empty( $this->cssnotheme ) ? 0 : 1;
            case 'reorder':
                return empty( $this->reorder ) ? 0 : 1;
            case 'handling':
                return empty( $this->handling ) ? 'primary' : $this->handling;
            case 'child_name':
                return stripslashes( $this->child_name );
            case 'author':
                return stripslashes( $this->child_author );
            case 'themeuri':
                return isset( $this->child_themeuri ) ? $this->child_themeuri : FALSE;
            case 'authoruri':
                return isset( $this->child_authoruri ) ? $this->child_authoruri : FALSE;
            case 'descr':
                return isset( $this->child_descr ) ? stripslashes( $this->child_descr ) : FALSE;
            case 'tags':
                return isset( $this->child_tags ) ? stripslashes( $this->child_tags ) : FALSE;
            case 'version':
                return $this->child_version;
            case 'preview':
                $this->styles = '';
                if ( empty( $params[ 'key' ] ) || 'child' == $params[ 'key' ] ):
                    $this->read_stylesheet( 'child', $this->ctc()->get_child_stylesheet() );
                else:
                    if ( isset( $this->addl_css ) ):
                        foreach ( $this->addl_css as $file ):
                            $this->styles .= '/*** BEGIN ' . $file . ' ***/' . LF;
                            $this->read_stylesheet( 'parnt', $file );
                            $this->styles .= '/*** END ' . $file . ' ***/' . LF;
                        endforeach;
                    endif;
                    if ( $this->get_prop( 'hasstyles' ) && !$this->get_prop( 'ignoreparnt' ) ):
                        $this->styles .= '/*** BEGIN Parent style.css ***/' . LF;
                        $this->read_stylesheet( 'parnt', 'style.css' );
                        $this->styles .= '/*** END Parent style.css ***/' . LF;
                    endif;
                    if ( 'separate' == $this->get_prop( 'handling' ) ):
                        $this->styles .= '/*** BEGIN Child style.css ***/' . LF;
                        $this->read_stylesheet( 'child', 'style.css' );
                        $this->styles .= '/*** END Child style.css ***/' . LF;
                    endif;
                endif;
                $this->normalize_css();
                return $this->styles;
                break;
            default:
                return $this->obj_to_utf8( apply_filters( 'chld_thm_get_prop', NULL, $property, $params ) );
        endswitch;
        return FALSE;
    }

    /**
     * set_prop
     * Setter interface (scalar values only)
     */
    function set_prop( $property, $value ) {
        if ( is_null( $this->{ $property } ) || is_scalar( $this->{ $property } ) )
            $this->{ $property } = $value;
        else return FALSE;
    }
    
    // formats css string for accurate parsing
    function normalize_css() {
        if ( preg_match( "/(\}[\w\#\.]|; *\})/", $this->styles ) ):                     // prettify compressed CSS
            $this->styles = preg_replace( "/\*\/\s*/s", "*/\n",     $this->styles );    // end comment
            $this->styles = preg_replace( "/\{\s*/s", " {\n    ",   $this->styles );    // open brace
            $this->styles = preg_replace( "/;\s*/s", ";\n    ",     $this->styles );    // semicolon
            $this->styles = preg_replace( "/\s*\}\s*/s", "\n}\n",   $this->styles );    // close brace
        endif;
    }
    
    function quotify_dependencies( $prop ) {
        $arr = array();
        foreach ( array_diff( $this->{ $prop }, $this->get_prop( 'forcedep' ) ) as $el )
            $arr[] = "'" . str_replace("'", "\'", $el ) . "'";
        return $arr;
    }
    
    // creates header comments for stylesheet
    function get_css_header() {
        return array(
            'Theme Name'    => $this->get_prop( 'child_name' ),
            'Theme URI'     => ( ( $attr = $this->get_prop( 'themeuri' ) ) ? $attr : '' ),
            'Template'      => $this->get_prop( 'parnt' ),
            'Author'        => $this->get_prop( 'author' ),
            'Author URI'    => ( ( $attr = $this->get_prop( 'authoruri' ) ) ? $attr : '' ),
            'Description'   => ( ( $attr = $this->get_prop( 'descr' ) ) ? $attr : '' ),
            'Tags'          => ( ( $attr = $this->get_prop( 'tags' ) ) ? $attr : '' ),
            'Version'       => $this->get_prop( 'version' ) . '.' . time(),
            'Updated'       => current_time( 'mysql' ),
        );
    }

    function get_css_header_comment( $handling = 'primary' ) {
        if ( 'separate' == $handling ):
            $contents = "/*" . LF
                . 'CTC Separate Stylesheet' . LF
                . 'Updated: ' . current_time( 'mysql' ) . LF
                . '*/' . LF;
        else:
            $contents = "/*" . LF;
            foreach ( $this->get_css_header() as $param => $value ):
                if ( $value ):
                    $contents .= $param . ': ' . $value . LF;
                endif;
            endforeach;
            $contents .= LF . "*/" . LF . $this->get_css_imports();
                    
        endif;
        return $contents;
    }
    
    function get_css_imports() {
        $newheader = '';
        if ( 'import' == $this->get_prop( 'enqueue' ) ):
            $this->ctc()->debug( 'using import ', __FUNCTION__, __CLASS__ );
            if ( ! $this->get_prop( 'ignoreparnt' ) )
                $newheader .= "@import url('../" . $this->get_prop( 'parnt' ) . "/style.css');" . LF;
        endif;
        return $newheader;
    }
    
    // formats file path for child theme file
    function get_child_target( $file = '', $theme = NULL ) {
        return trailingslashit( get_theme_root() ) . trailingslashit( $theme ? $theme : $this->get_prop( 'child' ) ) . $file;
    }
    
    // formats file path for parent theme file
    function get_parent_source( $file = 'style.css', $theme = NULL ) {
        return trailingslashit( get_theme_root() ) . trailingslashit( $theme ? $theme : $this->get_prop( 'parnt' ) ) . $file;
    }
    
    /**
     * get_dict_id
     * lookup function retrieves normalized id from string input
     * automatically adds to dictionary if it does not exist
     * incrementing key value for dictionary
     */
    function get_dict_id( $dict, $value ) {
        if ( FALSE === ( $id = $this->lookup_dict_value( $dict, $value ) ) ):
            // add value to dictionary
            $id = ++$this->{ $dict . 'key' };
            $this->set_dict_value( $dict, $value, $id );
        endif;
        return $id;
    }
    
    function lookup_dict_value( $dict, $value ){
        //$this->ctc()->debug( 'dict: ' . $dict . ' value: %' . $value . '%', __FUNCTION__, __CLASS__ );
        $property = 'dict_' . $dict;
        if ( $id = array_search( (string) $value, $this->{ $property } ) )
            return $id;
        return FALSE;
    }
    
    function get_dict_value( $dict, $id ) {
        $property = 'dict_' . $dict;
        return ( isset( $this->{ $property }[ $id ] ) )
            ? $this->{ $property }[ $id ]
            : FALSE;
    }
    
    function set_dict_value( $dict, $value, $id ) {
        $property = 'dict_' . $dict;
        $this->{ $property }[ $id ] = ( string ) $value;
    }

    /**
     * get_qsid
     * query/selector id is the combination of two dictionary values
     * also throttles parsing if memory limit is reached
     */
    function get_qsid( $query, $sel ) {
        $qs = $this->get_dict_id( 'query', $query ) . ':' . $this->get_dict_id( 'sel', $sel );
        return $this->get_dict_id( 'qs', $qs );
    }
    
    function unpack_val_ndx( $qsid ){
        if ( isset( $this->val_ndx[ $qsid ] ) ):
            try {
                $this->packer->reset( $this->packer->decode( $this->val_ndx[ $qsid ] ) ); 
                return $this->packer->unpack();
            } catch ( Exception $e ){
                $this->ctc()->debug( 'Unpack failed -- ' . $e->getMessage(), __FUNCTION__, __CLASS__ );
                return FALSE;
            }
        endif;
        return FALSE;
    }
    
    function pack_val_ndx( $qsid, $valarr ){
        try {
            $this->val_ndx[ $qsid ] = $this->packer->encode( $this->packer->pack( $valarr ) );
        } catch ( Exception $e ){
            $this->ctc()->debug( 'Pack failed -- ' . $e->getMessage(), __FUNCTION__, __CLASS__ );
        }
    }
    
    /**
     * update_arrays
     * accepts CSS properties as raw strings and normilizes into 
     * CTC object arrays, creating update cache in the process.
     * ( Update cache is returned to UI via AJAX to refresh page )
     * This has been refactored in v1.7.5 to accommodate multiple values per property.
     * @param   $template   p or c
     * @param   $query      media query 
     * @param   $sel        selector
     * @param   $rule       property (rule)
     * @param   $value      individual value ( property has array of values )
     * @param   $important  important flag for value
     * @param   $rulevalid  unique id of value for property
     * @param   $reset      clear current values to prevent multiple values from being generated from Raw CSS post input data
     * @return  $qsid       query/selector id for this entry
     */
    function update_arrays( 
        $template, 
        $query, 
        $sel, 
        $rule       = NULL, 
        $value      = NULL, 
        $important  = 0, 
        $rulevalid  = NULL, 
        $reset      = FALSE 
        ) {
        // if ( $this->max_sel ) return; // Future use
        if ( FALSE === strpos( $query, '@' ) )
            $query = 'base';
        // normalize selector styling
        $sel = implode( ', ', preg_split( '#\s*,\s*#s', trim( $sel ) ) );
        $qsid = $this->get_qsid( $query, $this->tokenize( $sel ) );
        // set data and value
        if ( $rule ):
            // get ids and quit if max is reached ( get_qsid handles )
            $ruleid = $this->get_dict_id( 'rule', $rule );
            $valid  = $this->get_dict_id( 'val', $value );
            /**
             * v2.1.0
             * pack/unpack val_ndx 
             */
            // create empty array IF value array does not exist
            if ( FALSE === ( $valarr = $this->unpack_val_ndx( $qsid ) ) )
                $valarr = array(
                    $ruleid => array(
                        $template => array(),
                    ),
                );
            // create empty array IF rule array does not exist
            if ( !isset( $valarr[ $ruleid ] ) )
                $valarr[ $ruleid ] = array(
                    $template => array(),
                );
            // create empty rule array if template is child and reset is TRUE 
            // or IF template array does not exist
            if ( ( $reset && 'child' == $template ) || !isset( $valarr[ $ruleid ][ $template ] ) )
                $valarr[ $ruleid ][ $template ] = array();

            // rulevalid passed            
            //$this->ctc()->debug( 'rule: ' . $rule . ' ' . $ruleid . ' value: ' . ( '' == $value? 'NULL' : '%' . $value . '%' ) . ' ' . ( FALSE == $valid ? 'FALSE' : $valid ) . ' valarr: ' . print_r( $valarr, TRUE ), __FUNCTION__, __CLASS__ );
            if ( isset( $rulevalid ) ):
                $this->unset_rule_value( $valarr[ $ruleid ][ $template ], $rulevalid );
                // value empty?
                if ( '' === $value ):
                // value exist?
                elseif ( $id = $this->rule_value_exists( $valarr[ $ruleid ][ $template ], $valid ) ):
                    $this->unset_rule_value( $valarr[ $ruleid ][ $template ], $id );
                    $this->update_rule_value( $valarr[ $ruleid ][ $template ], $rulevalid, $valid, $important );
                // update new value
                else:
                    $this->update_rule_value( $valarr[ $ruleid ][ $template ], $rulevalid, $valid, $important );
                endif;
            // rulevalid not passed
            else:
                // value exist?
                if ( $id = $this->rule_value_exists( $valarr[ $ruleid ][ $template ], $valid ) ):
                    $this->unset_rule_value( $valarr[ $ruleid ][ $template ], $id );
                    $this->update_rule_value( $valarr[ $ruleid ][ $template ], $id, $valid, $important );
                // get new id and update new value
                else:
                    $id = $this->get_rule_value_id( $valarr[ $ruleid ][ $template ] );
                    $this->update_rule_value( $valarr[ $ruleid ][ $template ], $id, $valid, $important );
                endif;
            endif;
        
            // moved call to prune_if_empty to parse_post_data v2.2.5
        
            $this->pack_val_ndx( $qsid, $valarr );
            // return query selector id   
            return $qsid;
        endif;
    }
    
    /**
     * rule_value_exists
     * Determine if a value already exists for a property
     * and return its id
     */
    function rule_value_exists( &$arr, $valid ) {
        foreach ( $arr as $valarr ):
            if ( isset( $valarr[ 0 ] ) && isset( $valarr[ 2 ] ) && $valid == $valarr[ 0 ] ):
                return $valarr[ 2 ];
            endif;
        endforeach;
        return FALSE;
    }
    
    /**
     * get_rule_value_id
     * Generate a new rulevalid by iterating existing ids
     * and returning the next in sequence
     */
    function get_rule_value_id( &$arr ) {
        $newid = 1;
        foreach ( $arr as $valarr )
            if ( isset( $valarr[ 2 ] ) && $valarr[ 2 ] >= $newid ) $newid = $valarr[ 2 ] + 1;
        return $newid;
    }
    
    /**
     * update_rule_value
     * Generate a new value subarray
     */
    function update_rule_value( &$arr, $id, $valid, $important ) {
        $arr[] = array(
            $valid,
            $important,
            $id,
        );
    }

    /** 
     * unset_rule_value
     * Delete (splice) old value subarray from values 
     */
    function unset_rule_value( &$arr, $id ) {
        $index = 0;
        foreach ( $arr as $valarr ):
            if ( $id == $valarr[ 2 ] ):
                array_splice( $arr, $index, 1 );
                break;
            endif;
            ++$index;
        endforeach;
    }
    
    /** 
     * prune_if_empty
     * Automatically cleans up hierarchies when no values exist 
     * in either parent or child for a given selector.
     */
    function prune_if_empty( $qsid ) {
        $empty = $this->get_dict_id( 'val', '' );
        if ( FALSE == ( $valarr = $this->unpack_val_ndx( $qsid ) ) ) return FALSE;
        foreach ( $valarr as $ruleid => $arr ):
            foreach ( array( 'c', 'p' ) as $template ):
                if ( isset( $arr[ $template ] ) ):
                    // v1.7.5: don't prune until converted to multi value format
                    if ( !is_array( $arr[ $template ] ) ) return FALSE; 
                    // otherwise check each value, if not empty return false
                    foreach ( $arr[ $template ] as $valarr ) 
                        if ( $empty != $valarr[ 0 ] ) return FALSE;
                endif;
            endforeach;
        endforeach;
        // no values, prune from sel index, val index and qs dict data ( keep other dictionary records )
        unset( $this->val_ndx[ $qsid ] );
        unset( $this->dict_qs[ $qsid ] );
        unset( $this->dict_seq[ $qsid ] );
        return TRUE;
    }
    
    /**
     * recurse_directory
     * searches filesystem for valid files based on parameters and returns array of filepaths.
     * Core WP recurse function is not used because we require logic specific to CTC.
     */
    function recurse_directory( $rootdir, $ext = 'css', $all = FALSE ) {
        // make sure we are only recursing theme and plugin files
        if ( !$this->is_file_ok( $rootdir, 'search' ) ) 
            return array(); 
        $files = array();
        $dirs = array( $rootdir );
        $loops = 0;
        if ( 'img' == $ext )
            $ext = '(' . implode( '|', array_keys( $this->ctc()->imgmimes ) ) . ')';
        while( count( $dirs ) && $loops < CHLD_THM_CFG_MAX_RECURSE_LOOPS ): // failsafe valve
            $loops++;
            $dir = array_shift( $dirs );
            if ( $handle = opendir( $dir ) ):
                while ( FALSE !== ( $file = readdir( $handle ) ) ):
                    if ( preg_match( "/^\./", $file ) ) continue;
                    $filepath  = trailingslashit( $dir ) . $file;
                    if ( is_dir( $filepath ) ):
                        array_unshift( $dirs, $filepath );
                        if ( $all ):
                            $files[] = $filepath; 
                        endif;
                    elseif ( is_file( $filepath ) && ( $all || preg_match( "/\.".$ext."$/i", $filepath ) ) ):
                        $files[] = $filepath;
                    endif;
                endwhile;
                closedir( $handle );
            endif;
        endwhile;
        return $files;
    }
    
    /**
     * parse_post_data
     * Parse user form input into separate properties and pass to update_arrays
     * FIXME - this function has grown too monolithic - refactor and componentize
     */
    function parse_post_data() {
        $this->load_config( 'dict_query' );
        $this->load_config( 'dict_sel' );
        $this->load_config( 'dict_token' );
        $this->load_config( 'dict_rule' );
        $this->load_config( 'dict_val' );
        $this->load_config( 'val_ndx' );
        $this->load_config( 'dict_seq' );
        $this->load_config( 'dict_qs' );
        $this->cache_updates = TRUE;
        // process RAW CSS input
        if ( isset( $_POST[ 'ctc_new_selectors' ] ) ):
            $this->styles = $this->parse_css_input( LF . $_POST[ 'ctc_new_selectors' ] );
            $this->parse_css( 'child', 
                isset( $_POST[ 'ctc_sel_ovrd_query' ] ) ? trim( $_POST[ 'ctc_sel_ovrd_query' ] ) : NULL, 
                FALSE, 
                '', 
                TRUE
            );
        // process WEB FONTS & CSS inputs
        elseif ( isset( $_POST[ 'ctc_child_imports' ] ) ):
            $this->imports[ 'child' ] = array();
            $this->styles = $this->parse_css_input( $_POST[ 'ctc_child_imports' ] );
            $this->parse_css( 'child' );
        // process CONFIGURE inputs
        elseif ( isset( $_POST[ 'ctc_configtype' ] ) ):
            ob_start();
            do_action( 'chld_thm_cfg_get_stylesheets' );
            $this->ctc()->updates[] = array(
                'obj'   => 'stylesheets',
                'key'   => '',
                'data'  => ob_get_contents(),
            );
            ob_end_clean();
            ob_start();
            do_action( 'chld_thm_cfg_get_backups' );
            $this->ctc()->updates[] = array(
                'obj'   => 'backups',
                'key'   => '',
                'data'  => ob_get_contents(),
            );
            ob_end_clean();
            return;
        // process SAVE inputs
        else:
            // New query added v2.3.0
            $newquery = isset( $_POST[ 'ctc_rewrite_query' ] ) ? 
                $this->sanitize( $this->parse_css_input( $_POST[ 'ctc_rewrite_query' ] ) ) : NULL;
            $newselector = isset( $_POST[ 'ctc_rewrite_selector' ] ) ? 
                $this->sanitize( $this->parse_css_input( $_POST[ 'ctc_rewrite_selector' ] ) ) : NULL;
            $newqsid = NULL;
        
            // set the custom sequence value
            foreach ( preg_grep( '#^ctc_ovrd_child_seq_#', array_keys( $_POST ) ) as $post_key ):
                if ( preg_match( '#^ctc_ovrd_child_seq_(\d+)$#', $post_key, $matches ) ):
                    $qsid = $matches[ 1 ];
                    $seq = intval( $_POST[ $post_key ] );
                    $this->ctc()->debug( 'set seq( ' . $qsid . ' ): custom: ' . $seq, __FUNCTION__, __CLASS__ );
                    if ( $seq != $qsid ):
                        $this->set_dict_value( 'seq', $seq, $qsid );
                    else:
                        unset( $this->dict_seq[ $seq ] );
                    endif;
                endif;
            endforeach;
        
            // iterate each property input
            $parts = array();
            foreach ( preg_grep( '#^ctc_(ovrd|\d+)_child#', array_keys( $_POST ) ) as $post_key ):
        
                // parse input key into individual components if it matches specific format, skip otherwise
                if ( preg_match( '#^ctc_(ovrd|\d+)_child_([\w\-]+?)_(\d+?)_(\d+?)(_(.+))?$#', $post_key, $matches ) ):
                    $valid      = $matches[ 1 ]; // this is used for inputs from property value tab
                    $rule       = $matches[ 2 ]; // property name 
                    if ( NULL == $rule || FALSE === $this->lookup_dict_value( 'rule', $rule ) )
                        continue;
                    $qsid       = $matches[ 3 ]; // query/selector id 
                    $rulevalid  = $matches[ 4 ]; // id to identify multiple values of same property
                    // normalize input value
                    $value      = $this->normalize_color( $this->sanitize( $this->parse_css_input( $_POST[ $post_key ] ) ) );
                    // set important flag
                    $important  = $this->is_important( $value ); // strip and set if !important passed in input
                    // set important if checkbox input is set 
                    if ( !empty( $_POST[ 'ctc_' . $valid . '_child_' . $rule . '_i_' . $qsid . '_' . $rulevalid ] ) ) $important = 1;
        
                    // get current values from query/selector id if it exists, skip this property otherwise
                    $selarr = $this->denorm_query_sel( $qsid );
                    if ( empty( $selarr ) ) continue;
        
                    // if there is a "rule-part" (e.g., border or gradient properties ), store in parts array and process separately.
                    if ( !empty( $matches[ 6 ] ) ):
                        $parts[ $qsid ][ $rule ][ 'values' ][ $rulevalid ][ $matches[ 6 ] ] = $value;
                        $parts[ $qsid ][ $rule ][ 'values' ][ $rulevalid ][ 'important' ]   = $important;
                        $parts[ $qsid ][ $rule ][ 'query' ]                                 = $selarr[ 'query' ];
                        $parts[ $qsid ][ $rule ][ 'selector' ]                              = $selarr[ 'selector' ];
                    // otherwise process this property
                    else:
                        $newqsid = $this->update_property(
                            $newquery,
                            $newselector,
                            $selarr[ 'query' ], 
                            $selarr[ 'selector' ], 
                            $rule, 
                            $value, 
                            $important, 
                            $rulevalid
                        );
                    endif;
                endif;
            endforeach;
            /** 
             * Inputs for border and background-image are broken into multiple "rule parts"
             * With the addition of multiple property values in v1.7.5, the parts loop 
             * has been modified to segment the parts into rulevalids under a new 'values' array. 
             * The important flag has also been moved into the parts array.
             */
            foreach ( $parts as $qsid => $rules ):
                foreach ( $rules as $rule => $rule_arr ):
                    // new 'values' array to segment parts into rulevalids
                    foreach ( $rule_arr[ 'values' ] as $rulevalid => $rule_part ):
                        if ( 'background' == $rule ):
                            $value = $rule_part[ 'background_url' ];
                        elseif ( 'background-image' == $rule ):
                            if ( empty( $rule_part[ 'background_url' ] ) ):
                                // custom multi-stop or radial gradients can be passed verbatim in the origin field
                                // but will not be parsed for vender-prefix support.
                                if ( !empty( $rule_part[ 'background_origin' ] )
                                    && preg_match( '{gradient}', $rule_part[ 'background_origin' ] ) ):
                                    $value = $rule_part[ 'background_origin' ];
                                    
                                elseif ( empty( $rule_part[ 'background_color2' ] ) ):
                                    $value = '';
                                else:
                                    if ( empty( $rule_part[ 'background_origin' ] ) )
                                        $rule_part[ 'background_origin' ] = 'top';
                                    if ( empty( $rule_part[ 'background_color1' ] ) )
                                        $rule_part[ 'background_color1' ] = $rule_part[ 'background_color2' ];
                                    $value = implode( ':', array(
                                        $rule_part[ 'background_origin' ], 
                                        $rule_part[ 'background_color1' ], '0%', 
                                        $rule_part[ 'background_color2' ], '100%'
                                    ) );
                                endif;
                            else:
                                $value = $rule_part[ 'background_url' ];
                            endif;
                        elseif ( preg_match( '#^border(\-(top|right|bottom|left))?$#', $rule ) ):
                            if ( empty( $rule_part[ 'border_width' ] ) && !empty( $rule_part[ 'border_color' ] ) )
                                $rule_part[ 'border_width' ] = '1px';
                            if ( empty( $rule_part[ 'border_style' ] ) && !empty( $rule_part[ 'border_color' ] ) )
                                $rule_part[ 'border_style' ] = 'solid';
                            $value = implode( ' ', array(
                                $rule_part[ 'border_width' ], 
                                $rule_part[ 'border_style' ], 
                                $rule_part[ 'border_color' ]
                            ) );
                        else:
                            $value = '';
                        endif;
                        
                        $newqsid = $this->update_property(
                            $newquery,
                            $newselector,
                            $rule_arr[ 'query' ],
                            $rule_arr[ 'selector' ], 
                            $rule,
                            $value,
                            $rule_part[ 'important' ],
                            $rulevalid
                        );

                    endforeach;
                endforeach;
            endforeach;
        
            // remove if all values have been cleared - moved from update_arrays v2.2.5
            $this->prune_if_empty( $qsid );
        
            if ( $newqsid != $qsid )
                $qsid = $newqsid;
        
            // return updated qsid to browser to update form
            if ( $this->ctc()->cache_updates )
                $this->ctc()->updates[] = array(
                    'obj'   => 'qsid',
                    'key'   => $qsid,
                    'data'  => $this->obj_to_utf8( $this->denorm_sel_val( $qsid ) ),
                );
        
            do_action( 'chld_thm_cfg_update_qsid', $qsid );                
        endif;

        // update enqueue function if imports have not been converted or new imports passed
        if ( isset( $_POST[ 'ctc_child_imports' ] ) || !$this->get_prop( 'converted' ) )
            add_action( 'chld_thm_cfg_addl_files',   array( $this->ctc(), 'enqueue_parent_css' ), 15, 2 );
    }
    
    /**
     * standarized property update function
     * added v2.3.0
     */
    function update_property(
        $newquery,
        $newselector,
        $query,
        $selector, 
        $rule,
        $value,
        $important,
        $rulevalid
    ){
        // If this is a renamed selector, add new selector to data
        // otherwise update existing selector
        $newqsid = $this->update_arrays( 
            'c',
            $newquery ? $newquery : $query,
            $newselector ? $newselector : $selector,
            $rule,
            trim( $value ),
            $important,
            $rulevalid
        );
        // if query or selector have been renamed, 
        // clear the original selector's value:
        if ( $newquery || $newselector ):
            $qsid = $this->update_arrays(
                'c',
                $query,
                $selector,
                $rule,
                '',
                0,
                $rulevalid
            );
            // add new sequence entry
            $seq = $this->get_dict_value( 'seq', $qsid );
            $this->set_dict_value( 'seq', $newqsid, $seq );
        endif;
        return $newqsid;
    }
    
    /**
     * parse_css_input
     * Normalize raw user CSS input so that the parser can read it.
     */
    function parse_css_input( $styles ) {
        return $this->repl_octal( stripslashes( $this->esc_octal( $styles ) ) );
    }
    
    // strips non printables and potential commands
    function sanitize( $styles ) {
        return sanitize_text_field( preg_replace( '/[^[:print:]]|[\{\}].*/', '', $styles ) );
    }
    
    // escapes octal values in input to allow for specific ascii strings in content rule
    function esc_octal( $styles ){
        return preg_replace( "#(['\"])\\\\([0-9a-f]{4})(['\"])#i", "$1##bs##$2$3", $styles );
    }
    
    // unescapes octal values for writing specific ascii strings in content rule
    function repl_octal( $styles ) {
        return str_replace( "##bs##", "\\", $styles );
    }
    
    /**
     * parse_css_file
     * reads stylesheet to get WordPress meta data and passes rest to parse_css 
     */
    function parse_css_file( $template, $file = 'style.css', $cfgtemplate = FALSE ) {
        if ( '' == $file ) $file = 'style.css';
        
        /**
         * Future use: have we run out of memory?
         *
        if ( $this->max_sel ):
            //$this->ctc()->debug( 'Insufficient memory to parse file.', __FUNCTION__, __CLASS__ );
            return FALSE;
        endif;
        */
        // turn off caching when parsing files to reduce memory usage
        $this->ctc()->cache_updates = FALSE;
        $this->styles = ''; // reset styles
        $this->read_stylesheet( $template, $file );
        // get theme name
        $regex = '#Theme Name:\s*(.+?)\n#i';
        preg_match( $regex, $this->styles, $matches );
        $child_name = $this->get_prop( 'child_name' );
        if ( !empty( $matches[ 1 ] ) && 'child' == $template && empty( $child_name ) ) $this->set_prop( 'child_name', $matches[ 1 ] );
        $this->parse_css( 
            $cfgtemplate ? $cfgtemplate : $template, 
            NULL, 
            TRUE, 
            $this->ctc()->normalize_path( dirname( $file ) )
        );
    }

    // loads raw css file into local memory
    function read_stylesheet( $template = 'child', $file = 'style.css' ) {
        
        // these conditions support revert/restore option in 1.6.0+
        if ( 'all' == $file ) return;
        elseif ( '' == $file ) $file = 'style.css';
        // end revert/restore conditions
        
        $source = $this->get_prop( $template );
        if ( empty( $source ) || !is_scalar( $source ) ) return FALSE;
        $themedir = trailingslashit( get_theme_root() ) . $source;
        $stylesheet = apply_filters( 'chld_thm_cfg_' . $template, trailingslashit( $themedir ) 
            . $file , ( $this->ctc()->is_legacy() ? $this : $file ) ); // support for plugins extension < 2.0

        // read stylesheet
        
        if ( $stylesheet_verified = $this->is_file_ok( $stylesheet, 'read' ) ):
            /**
             * Future use: make sure we have space to parse
             *
            if ( filesize( $stylesheet_verified ) * 3 > $this->ctc()->get_free_memory() ):
                $this->max_sel = 1;
                //$this->ctc()->debug( 'Insufficient memory to read file', __FUNCTION__, __CLASS__ );
                return;
            endif;
            */
            $this->styles .= @file_get_contents( $stylesheet_verified ) . "\n";
            //echo 'count after get contents: ' . strlen( $this->styles ) . LF;
        else:
            //echo 'not ok!' . LF;
        endif;
    }

    /**
     * parse_css
     * Accepts raw CSS as text and parses into individual properties.
     * FIXME - this function has grown too monolithic - refactor and componentize
     * FIXME - migrate to event parser? handle comments?
     */
    function parse_css( $template, $basequery = NULL, $parse_imports = TRUE, $relpath = '', $reset = FALSE ) {
        //$this->load_config( 'sel_ndx' );
        $this->load_config( 'val_ndx' );
        $this->load_config( 'dict_query' );
        $this->load_config( 'dict_sel' );
        $this->load_config( 'dict_token' );
        $this->load_config( 'dict_qs' );
        $this->load_config( 'dict_val' );
        $this->load_config( 'dict_rule' );
        $this->load_config( 'dict_seq' );
        if ( FALSE === strpos( $basequery, '@' ) ):
            $basequery = 'base';
        endif;
        $ruleset = array();
        // ignore commented code
        $this->styles = preg_replace( '#\/\*.*?\*\/#s', '', $this->styles );
        // space braces to ensure correct matching
        $this->styles = preg_replace( '#([\{\}])\s*#', "$1\n", $this->styles );
        // get all imports
        if ( $parse_imports ):
            
            $regex = '#(\@import\s+url\(.+?\));#';
            preg_match_all( $regex, $this->styles, $matches );
            foreach ( preg_grep( '#' . $this->get_prop( 'parnt' ) . '\/style\.css#', $matches[ 1 ], PREG_GREP_INVERT ) as $import ):
                $import = preg_replace( "#^.*?url\(([^\)]+?)\).*#", "$1", $import );
                $import = preg_replace( "#[\'\"]#", '', $import );
                $import = '@import url(' . trim( $import ) . ')';
                $this->imports[ $template ][ $import ] = 1;
            endforeach;
            if ( $this->ctc()->cache_updates ):
                $this->ctc()->updates[] = array(
                    'obj'  => 'imports',
                    'data' => array_keys( $this->imports[ $template ] ),
                );
            endif;
        endif;
        // break into @ segments
        foreach ( array(
            '#(\@media[^\{]+?)\{(\s*?)\}#', // get any placehoder (empty) media queries
            '#(\@media[^\{]+?)\{(.*?\})?\s*?\}#s', // get all other media queries
        ) as $regex ): // (((?!\@media).) backreference too memory intensive - rolled back in v 1.4.8.1
            preg_match_all( $regex, $this->styles, $matches );
            foreach ( $matches[ 1 ] as $segment ):
                $segment = $this->normalize_query( $segment );
                $ruleset[ $segment ] = array_shift( $matches[ 2 ] ) 
                    . ( isset( $ruleset[ $segment ] ) ?
                        $ruleset[ $segment ] : '' );
            endforeach;
            // stripping rulesets leaves base styles
            $this->styles = preg_replace( $regex, '', $this->styles );
        endforeach;
        $ruleset[ $basequery ] = $this->styles;
        $qsid = NULL;
        foreach ( $ruleset as $query => $segment ):
            // make sure there is a newline before the first selector
            $segment = LF . $segment;
            // make sure there is semicolon before closing brace
            $segment = preg_replace( '#(\})#', ";$1", $segment );
            // parses selectors and corresponding rules
            $regex = '#\n\s*([\[\.\#\:\w][\w\-\s\(\)\[\]\'\^\*\.\#\+\~:,"=>]+?)\s*\{(.*?)\}#s';  //[^\{] may be to expensive
            preg_match_all( $regex, $segment, $matches );
            foreach( $matches[ 1 ] as $sel ):
                $stuff  = array_shift( $matches[ 2 ] );
                $this->update_arrays(
                    'child' == $template ? 'c' : 'p',
                    $query,
                    $sel
                );
                // handle base64 data
                $stuff = preg_replace( '#data:([^;]+?);([^\)]+?)\)#s', "data:$1%%semi%%$2)", $stuff );
                // rule semaphore makes sure rules are only reset the first time they appear
                $resetrule = array(); 
                foreach ( explode( ';', $stuff ) as $ruleval ):
                    if ( FALSE === strpos( $ruleval, ':' ) ) continue;
                    list( $rule, $value ) = explode( ':', $ruleval, 2 );
                    // trim, replace spaces with dashes, make lowercase
                    $rule   = preg_replace( '/\s+/', '-', trim( strtolower( $rule ) ) );
                    $rule   = preg_replace_callback( "/[^\w\-]/", array( $this, 'to_ascii' ), $rule );
                    // handle base64 data
                    $value  = trim( str_replace( '%%semi%%', ';', $value ) );
                    
                    $rules = $values = array();
                    // save important flag
                    $important = $this->is_important( $value );
                    // normalize color
                    $value = $this->normalize_color( $value );
                    // normalize font
                    if ( 'font' == $rule ):
                        $this->normalize_font( $value, $rules, $values );
                    // normalize background
                    elseif( 'background' == $rule ):
                        $this->normalize_background( $value, $rules, $values );
                    // normalize margin/padding
                    elseif ( 'margin' == $rule || 'padding' == $rule ):
                        $this->normalize_margin_padding( $rule, $value, $rules, $values );
                    else:
                        $rules[]    = $rule;
                        $values[]   = $value;
                    endif;
                    foreach ( $rules as $rule ):
                        $value = trim( array_shift( $values ) );
                        // normalize zero values
                        $value = preg_replace( '#\b0(px|r?em)#', '0', $value );
                        // normalize gradients
                        if ( FALSE !== strpos( $value, 'gradient' ) ):
                            if ( FALSE !== strpos( $rule, 'filter' ) ):
                                // treat as background-image, we'll add filter rule later
                                $rule = 'background-image';
                                continue; 
                            endif;
                            if ( FALSE !== strpos( $value, 'webkit-gradient' ) ) continue; // bail on legacy webkit, we'll add it later
                            $value = $this->encode_gradient( $value );
                        endif;
                        // normalize common vendor prefixes
                        $rule = preg_replace( '#(\-(o|ms|moz|webkit)\-)?(' . implode( '|', $this->vendorrule ) . ')#', "$3", $rule );
                        if ( 'parnt' == $template && 'background-image' == $rule && strstr( $value, 'url(' ) )
                            $value = $this->convert_rel_url( $value, $relpath );
                        /**
                         * The reset flag forces the values for a given property (rule) to be rewritten completely 
                         * when using the raw CSS input or when reading from a stylesheet.
                         * This permits complete blocks of style data to be entered verbatim, replacing existing styles.
                         * When entering individual values from the Query/Selector inputs, multiple fallback values for existing 
                         * properties can be added in the order they are entered (e.g., margin: 1rem; margin: 1em;)
                         */
                        if ( !$reset ) $resetrule[ $rule ] = TRUE; 
                        
                        $qsid = $this->update_arrays( 
                            'child' == $template ? 'c' : 'p',
                            $query, 
                            $sel, 
                            $rule, 
                            $value, 
                            $important, 
                            NULL, // no rulevalid is passed when parsing from css (vs post input data)
                            empty( $resetrule[ $rule ] ) // if rule semaphore is TRUE, reset will be FALSE
                        );
                        $resetrule[ $rule ] = TRUE; // set rule semaphore so if same rule occurs again, it is not reset
                    endforeach;
                endforeach;
            endforeach;
        endforeach;
        // if this is a raw css update pass the last selector back to the browser to update the form
        if ( $this->ctc()->cache_updates && $qsid ):
            $this->ctc()->updates[] = array(
                'obj'   => 'qsid',
                'key'   => $qsid,
                'data'  => $this->obj_to_utf8( $this->denorm_sel_val( $qsid ) ),
            );
            do_action( 'chld_thm_cfg_update_qsid', $qsid );                
        endif;
        
    }

    // converts relative path to absolute path for preview
    function convert_rel_url( $value, $relpath, $url = TRUE  ) {
        if ( preg_match( '/data:/', $value ) ) return $value;
        $path       = preg_replace( '%url\([\'" ]*(.+?)[\'" ]*\)%', "$1", $value );
        if ( preg_match( '%(https?:)?//%', $path ) ) return $value;
        $pathparts  = explode( '/', $path );
        $fileparts  = explode( '/', $relpath );
        $newparts   = array();
        while ( $pathpart = array_shift( $pathparts ) ):
            if ( '..' == $pathpart )
                array_pop( $fileparts );
            else array_push( $newparts, sanitize_text_field( $pathpart ) );
        endwhile;
        $newvalue = ( $url ? 'url(' : '' )
            . ( $fileparts ? trailingslashit( implode( '/', $fileparts ) ) : '' ) 
            . implode( '/', $newparts ) . ( $url ? ')' : '' );
        $this->ctc()->debug( 'converted ' . $value . ' to ' . $newvalue . ' with ' . $relpath, __FUNCTION__, __CLASS__ );
        return $newvalue;
    }
    
    /**
     * write_css
     * converts normalized CSS object data into stylesheet.
     * Preserves selector sequence and !important flags of parent stylesheet.
     * @media query blocks are sorted using internal heuristics (see sort_queries)
     * New selectors are appended to the end of each media query block.
     * FIXME - this function has grown too monolithic - refactor and componentize
     */
    function write_css() {
        $output  = '';
        foreach ( $this->sort_queries() as $query => $sort_order ):
            $has_selector = 0;
            $sel_output   = '';
            $selectors = $this->denorm_dict_qs( $query, FALSE );
            uasort( $selectors, array( $this, 'cmp_seq' ) );
            if ( 'base' != $query ) $sel_output .=  $query . ' {' . LF;
            foreach ( $selectors as $selid => $qsid ):
                if ( $valarr = $this->unpack_val_ndx( $qsid ) ):
                    $sel            = $this->detokenize( $this->get_dict_value( 'sel', $selid ) );
                    $shorthand      = array();
                    $rule_output    = array();
                    foreach ( $valarr as $ruleid => $temparr ):
                        // normalize values for backward compatability
                        if ( isset( $temparr[ 'c' ] ) && 
                            ( !isset( $temparr[ 'p' ] ) || $temparr[ 'p' ] != $temparr[ 'c' ] ) ):
                            foreach ( $temparr[ 'c' ] as $rulevalarr ):
                                $this->add_vendor_rules( 
                                    $rule_output,
                                    $shorthand,
                                    $this->get_dict_value( 'rule', $ruleid ),
                                    $this->get_dict_value( 'val', $rulevalarr[ 0 ] ),
                                    $rulevalarr[ 1 ],
                                    $rulevalarr[ 2 ]
                                );
                            endforeach;
                        /**
                         * for testing
                        else:
                            foreach ( $temparr[ 'parnt' ] as $rulevalarr ):
                                $this->add_vendor_rules( 
                                    $rule_output,
                                    $shorthand,
                                    $rulearr[ $ruleid ],
                                    $valarr[ $rulevalarr[ 0 ] ],
                                    $rulevalarr[ 1 ],
                                    $rulevalarr[ 2 ]
                                );
                            endforeach;
                          */
                        endif;
                    endforeach;
                    /** FIXME ** need better way to sort rules and multiple values ***/
                    $this->encode_shorthand( $shorthand, $rule_output );
                    if ( count( $rule_output ) ):
                        // show load order -- removed in v.1.7.6 by popular demand
                        //$sel_output .= isset( $this->dict_seq[ $qsid ] )?'/*' . $this->dict_seq[ $qsid ] . '*/' . LF:''; 
                        $sel_output .= $sel . ' {' . LF . $this->stringify_rule_output( $rule_output ) . '}' . LF; 
                        $has_selector = 1;
                    endif;
                endif;
            endforeach;
            if ( 'base' != $query ) $sel_output .= '}' . LF;
            if ( $has_selector ) $output .= $sel_output;
        endforeach;
        $output = $this->get_css_header_comment( $this->get_prop( 'handling' ) ) . LF . $output;
        $stylesheet = $this->get_stylesheet_path();
        $this->ctc()->debug( 'writing stylesheet: ' . $stylesheet, __FUNCTION__, __CLASS__ );
        //echo //print_r(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS), true) . LF;
        if ( $stylesheet_verified = $this->is_file_ok( $stylesheet, 'write' ) ):
            global $wp_filesystem; // this was initialized earlier;
            $mode = 'direct' == $this->ctc()->fs_method ? FALSE : 0666;
            // write new stylesheet:
            // try direct write first, then wp_filesystem write
            // stylesheet must already exist and be writable by web server
            if ( $this->ctc()->is_ajax ):
                if ( is_writable( $stylesheet_verified ) ):
                    $this->ctc()->debug( 'Attempting Ajax write...', __FUNCTION__, __CLASS__ );
                    if ( FALSE === @file_put_contents( $stylesheet_verified, $output ) ): 
                        $this->ctc()->debug( 'Ajax write failed.', __FUNCTION__, __CLASS__ );
                        return FALSE;
                    endif;
                else:
                    $this->ctc()->debug( 'File not writable.', __FUNCTION__, __CLASS__ );
                    return FALSE;
                endif;
            elseif ( FALSE === $wp_filesystem->put_contents( $this->ctc()->fspath( $stylesheet_verified ), $output, $mode ) ):
                $this->ctc()->debug( 'Filesystem write failed.', __FUNCTION__, __CLASS__ );
                return FALSE;
            endif;
            $this->ctc()->debug( 'No write failure reported.', __FUNCTION__, __CLASS__ );
            return TRUE;
        endif;
        $this->ctc()->debug( 'File NOT ok.', __FUNCTION__, __CLASS__ );

        return FALSE;
    }
    
    function stringify_rule_output( &$rule_output ) {
        $output = '';
        asort( $rule_output );
        foreach ( $rule_output as $rule => $sortstr )
            $output .= '    ' . $rule . ";\n";
        return $output;
    }
    
    function sortstr( $rule, $rulevalid ) {
        return substr( "0000" . $this->get_dict_id( 'rule', $rule ), -4) . substr( "00" . $rulevalid, -2 );
    }

    /**
     * encode_shorthand
     * converts CTC long syntax into CSS shorthand
     * v1.7.5 refactored for multiple values per property
     * v2.1.0 to prevent incorrect rendering, do not use shorthand if multiple values exist for any side property.
     */
    function encode_shorthand( $shorthand, &$rule_output ) {
        foreach ( $shorthand as $property => $sides ):
            if ( isset( $sides[ 'top' ] ) && 1 == count( $sides[ 'top' ] ) ):
                foreach ( $sides[ 'top' ] as $tval => $tarr ):
                    if ( isset( $sides[ 'right' ] ) && 1 == count( $sides[ 'right' ] ) ):
                        $currseq = $tarr[ 1 ];
                        foreach ( $sides[ 'right' ] as $rval => $rarr ):
                            // value must exist from side and priority must match all sides
                            if ( isset( $sides[ 'bottom' ] ) && 1 == count( $sides[ 'bottom' ] ) && $tarr[ 0 ] == $rarr[ 0 ] ):
                                if ( $rarr[ 1 ] > $currseq ) $currseq = $rarr[ 1 ];
                                foreach ( $sides[ 'bottom' ] as $bval => $barr ):
                                    if ( isset( $sides[ 'left' ] ) && 1 == count( $sides[ 'left' ] ) && $tarr[ 0 ] == $barr[ 0 ] ):
                                        // use highest sort sequence of all sides
                                        if ( $barr[ 1 ] > $currseq ) $currseq = $barr[ 1 ];
                                        foreach ( $sides[ 'left' ] as $lval => $larr ):
                                            if ( $tarr[ 0 ] != $larr[ 0 ] ) continue;
                                            if ( $larr[ 1 ] > $currseq ) $currseq = $larr[ 1 ];

                                            $combo = array(
                                                $tval,
                                                $rval,
                                                $bval,
                                                $lval,
                                            );
                                            // echo 'combo before: ' . print_r( $combo, TRUE ) . LF;
                                            // remove from shorthand array
                                            unset( $shorthand[ $property ][ 'top' ][ $tval ] );
                                            unset( $shorthand[ $property ][ 'right' ][ $rval ] );
                                            unset( $shorthand[ $property ][ 'bottom' ][ $bval ] );
                                            unset( $shorthand[ $property ][ 'left' ][ $lval ] );
                                            
                                            // combine into shorthand syntax
                                            if ( $lval === $rval ):
                                                //echo 'left same as right, popping left' . LF;
                                                array_pop( $combo );
                                                if ( $bval === $tval ):
                                                    //echo 'bottom same as top, popping bottom' . LF;
                                                    array_pop( $combo );
                                                    if ( $rval === $tval ): // && $bval === $tval ):
                                                        //echo 'right same as top, popping right' . LF;
                                                        array_pop( $combo );
                                                    endif;
                                                endif;
                                            endif;
                                            //echo 'combo after: ' . print_r( $combo, TRUE ) . LF;
                                            // set rule
                                            $rule_output[ $property . ': ' . implode( ' ', $combo ) . ( $tarr[ 0 ] ? ' !important' : '' ) ] = $this->sortstr( $property, $currseq );
                                            // reset sort sequence
                                            $currseq = 0;
                                        endforeach;
                                    endif;
                                endforeach;
                            endif;
                        endforeach;
                    endif;
                endforeach;
            endif;
        endforeach;
        // add remaining rules
        foreach ( $shorthand as $property => $sides ):
            foreach ( $sides as $side => $values ):
                $rule = $property . '-' . $side;
                foreach ( $values as $val => $valarr ):
                    // set rule
                    $rule_output[ $rule . ': ' . $val . ( $valarr[ 0 ] ? ' !important' : '' ) ] = $this->sortstr( $rule, $valarr[ 1 ] );
                endforeach;
            endforeach;
        endforeach;
    }
    
    /**
     * add_vendor_rules
     * Applies vendor prefixes to rules/values and separates out shorthand properties .
     * These are based on commonly used practices and not all vendor prefixes are supported.
     * TODO: verify this logic against vendor and W3C documentation
     */
    function add_vendor_rules( &$rule_output, &$shorthand, $rule, $value, $important, $rulevalid ) {
        if ( '' === trim( $value ) ) return;
        if ( 'filter' == $rule && ( FALSE !== strpos( $value, 'progid:DXImageTransform.Microsoft.Gradient' ) ) ) return;
        $importantstr = $important ? ' !important' : '';
        if ( preg_match( "/^(margin|padding)\-(top|right|bottom|left)$/", $rule, $matches ) ):
            $shorthand[ $matches[ 1 ] ][ $matches[ 2 ] ][ $value ] = array(
                $important,
                $rulevalid,
                );
            return;
        elseif ( preg_match( '/^(' . implode( '|', $this->vendorrule ) . ')$/', $rule ) ):
            foreach( array( 'moz', 'webkit', 'o' ) as $prefix ):
                $rule_output[ '-' . $prefix . '-' . $rule . ': ' . $value . $importantstr ] = $this->sortstr( $rule, $rulevalid++ );
            endforeach;
            $rule_output[ $rule . ': ' . $value . $importantstr ] = $this->sortstr( $rule, $rulevalid );
        elseif ( 'background-image' == $rule ):
            // gradient?
            
            if ( $gradient = $this->decode_gradient( $value ) ):
                // standard gradient
                foreach( array( 'moz', 'webkit', 'o', 'ms' ) as $prefix ):
                    // build key before dereferencing array - v.2.3.0.3
                    $propkey = 'background-image: -' . $prefix . '-' . 'linear-gradient(' . $gradient[ 'origin' ] . ', ' 
                        . $gradient[ 'color1' ] . ', ' . $gradient[ 'color2' ] . ')' . $importantstr;
                    $rule_output[ $propkey ] = $this->sortstr( $rule, $rulevalid++ );
                endforeach;
                // W3C standard gradient
                // rotate origin 90 degrees
                if ( preg_match( '/(\d+)deg/', $gradient[ 'origin' ], $matches ) ):
                    $org = ( 90 - $matches[ 1 ] ) . 'deg';
                else: 
                    foreach ( preg_split( "/\s+/", $gradient[ 'origin' ] ) as $dir ):
                        $dir = strtolower( $dir );
                        $dirs[] = ( 'top' == $dir ? 'bottom' : 
                            ( 'bottom' == $dir ? 'top' : 
                                ( 'left' == $dir ? 'right' : 
                                    ( 'right' == $dir ? 'left' : $dir ) ) ) );
                    endforeach;
                    $org = 'to ' . implode( ' ', $dirs );
                endif;
                // build key before dereferencing array - v.2.3.0.3
                $propkey = 'background-image: linear-gradient(' . $org . ', ' 
                    . $gradient[ 'color1' ] . ', ' . $gradient[ 'color2' ] . ')' . $importantstr;
                $rule_output[ $propkey ] = $this->sortstr( $rule, $rulevalid );
                
                // legacy webkit gradient - we'll add if there is demand
                // '-webkit-gradient(linear,' .$origin . ', ' . $color1 . ', '. $color2 . ')';
                
                /** 
                 * MS filter gradient - DEPRECATED in v1.7.5
                 * $type = ( in_array( $gradient[ 'origin' ], array( 'left', 'right', '0deg', '180deg' ) ) ? 1 : 0 );
                 * $color1 = preg_replace( "/^#/", '#00', $gradient[ 'color1' ] );
                 * $rule_output[ 'filter: progid:DXImageTransform.Microsoft.Gradient(GradientType=' . $type . ', StartColorStr="' 
                 *    . strtoupper( $color1 ) . '", EndColorStr="' . strtoupper( $gradient[ 'color2' ] ) . '")' 
                 *    . $importantstr ] = $this->sortstr( $rule, $rulevalid );
                 */
            else:
                // url or other value
                $rule_output[ $rule . ': ' . $value . $importantstr ] = $this->sortstr( $rule, $rulevalid );
            endif;
        else:
            $rule = preg_replace_callback( "/\d+/", array( $this, 'from_ascii' ), $rule );
            $rule_output[ $rule . ': ' . $value . $importantstr ] = $this->sortstr( $rule, $rulevalid );
        endif;
    }

    /**
     * normalize_background
     * parses background shorthand value and returns
     * normalized rule/value pairs for each property
     */
    function normalize_background( $value, &$rules, &$values ) {
        if ( FALSE !== strpos( $value, 'gradient' ) ):
            // only supporting linear syntax
            if ( preg_match( '#(linear\-|Microsoft\.)#', $value ) ):
                $values[] = $value;
                $rules[] = 'background-image';
            else:
                // don't try to normalize non-linear gradients
                $values[] = $value;
                $rules[] = 'background';
            endif;
        else:
            $regexes = array(
                'image'         => 'url *\\([^)]+?\\)|none',
                'attachment'    => 'scroll|fixed|local',
                'clip'          => '(padding|border|content)\\-box',
                'repeat'        => '(no\\-)?repeat(\\-(x|y))?|round|space',
                'size'          => 'cover|contain|auto',
                'position'      => 'top|bottom|left|right|center|\b0 +0\b|(\b0 +)?[\\-\\d.]+(px|%)( +0\b)?',
                'color'         => '\\#[a-fA-F0-9]{3,6}|(hsl|rgb)a? *\\([^)]+?\\)|[a-z]+'                
            );
            //echo '<pre><code>' . "\n";
            //echo '<strong>' . $value . '</strong>' . "\n";
            foreach ( $regexes as $property => $regex ):
                $this->temparray = array();
                //echo $property . ': ' . $regex . "\n";
                $value = preg_replace_callback( "/(" . $regex . ")/", array( $this, 'background_callback' ), $value );
                if ( count( $this->temparray ) ):
                    $rules[] = 'background-' . $property;
                    $values[] = implode( ' ', $this->temparray );
                    //echo '<strong>result: ' . implode( ' ', $this->temparray ) . "</strong>\n";
                endif;
            endforeach;
            //echo '</code></pre>' . "\n";
        endif;
    }
    
    function background_callback( $matches ) {
        $this->temparray[] = $matches[ 1 ];
    }

    /**
     * normalize_font
     * parses font shorthand value and returns
     * normalized rule/value pairs for each property
     */
    function normalize_font( $value, &$rules, &$values ) {
        $regex = '#^((\d+|bold|normal) )?((italic|normal) )?(([\d\.]+(px|r?em|%))[\/ ])?(([\d\.]+(px|r?em|%)?) )?(.+)$#is';
        preg_match( $regex, $value, $parts );
        if ( !empty( $parts[ 2 ] ) ):
            $rules[]    = 'font-weight';
            $values[]   = $parts[ 2 ];
        endif;
        if ( !empty( $parts[ 4 ] ) ):
            $rules[]    = 'font-style';
            $values[]   = $parts[ 4 ];
        endif;      
        if ( !empty( $parts[ 6 ] ) ):
            $rules[]    = 'font-size';
            $values[]   = $parts[ 6 ];
        endif;
        if ( !empty( $parts[ 9 ] ) ):
            $rules[]    = 'line-height';
            $values[]   = $parts[ 9 ];
        endif;
        if ( !empty( $parts[ 11 ] ) ):
            $rules[]    = 'font-family';
            $values[]   = $parts[ 11 ];
        endif;
    }

    /**
     * normalize_margin_padding
     * parses margin or padding shorthand value and returns
     * normalized rule/value pairs for each property
     */
    function normalize_margin_padding( $rule, $value, &$rules, &$values ) {
        $parts = preg_split( "/ +/", trim( $value ) );
        if ( !isset( $parts[ 1 ] ) ) $parts[ 1 ] = $parts[ 0 ];
        if ( !isset( $parts[ 2 ] ) ) $parts[ 2 ] = $parts[ 0 ];
        if ( !isset( $parts[ 3 ] ) ) $parts[ 3 ] = $parts[ 1 ];
        $rules[ 0 ]   = $rule . '-top';
        $values[ 0 ]  = $parts[ 0 ];
        $rules[ 1 ]   = $rule . '-right';
        $values[ 1 ]  = $parts[ 1 ];
        $rules[ 2 ]   = $rule . '-bottom';
        $values[ 2 ]  = $parts[ 2 ];
        $rules[ 3 ]   = $rule . '-left';
        $values[ 3 ]  = $parts[ 3 ];
    }

    /**
     * encode_gradient
     * Normalize linear gradients from a bazillion formats into standard CTC syntax.
     * This has been refactored in v1.7.5 to accommodate new spectrum color picker color "names."
     * Currently only supports two-color linear gradients with no inner stops.
     * TODO: legacy webkit? more gradients? 
     */
    function encode_gradient( $value ) {
        // don't try this at home, kids
        $regex = '/gradient[^\)]*?\(    #exp    descr
        (                               #[1]
        (                               #[2]
        (to\x20)?                       #[3]    reverse
        (top|bottom|left|right)?        #[4]    direction1
        (\x20                           #[5]
        (top|bottom|left|right))?       #[6]    direction2
            |\d+deg),)?                 #       or angle
        (color-stop\()?                 #[7]    optional
        ([^\w\#\)]*[\'"]?               #[8]
        (\#\w{3,8}                      #[9]    color (hex)
            |rgba?\([\d.,\x20]+?\)      #       red green blue (alpha)
            |hsla?\([\d%.,\x20]+?\)     #       hue sat. lum. (alpha)
            |[a-z]+)                    #       color (name)
        (\x20+[\d.]+%?)?)               #[10]   stop position
        (\),\x20*)?                     #[11]   optional close
        (color-stop\()?                 #[12]   optional
        ([^\w\#\)]*[\'"]?               #[13]
        (\#\w{3,8}                      #[14]   color (hex)
            |rgba?\([\d.,\x20]+?\)      #       red green blue (alpha)
            |hsla?\([\d%.,\x20]+?\)     #       hue sat. lum. (alpha)
            |[a-z]+)                    #       color (name)
        (\x20+[\d.]+%?)?)               #[15]   stop position
        (\))?                           #[16]   optional close
        ([^\w\)]*gradienttype=[\'"]?    #[17]   IE
        (\d)                            #[18]   IE
        [\'"]?)?                        #       IE
        [^\w\)]*\)/ix';
        $param = $parts = array();
        preg_match( $regex, $value, $parts );
        //$this->ctc()->debug( 'gradient value: ' . $value . ' parts: ' . print_r( $parts, TRUE ), __FUNCTION__, __CLASS__ );
        if ( empty( $parts[ 18 ] ) ):
            if ( empty( $parts[ 2 ] ) ):
                $param[ 0 ] = 'top';
            elseif ( 'to ' == $parts[ 3 ] ):
            
                $param[ 0 ] = ( 'top' == $parts[ 4 ] ? 'bottom' :
                    ( 'left' == $parts[ 4 ] ? 'right' : 
                        ( 'right' == $parts[ 4 ] ? 'left' : 
                            'top' ) ) ) ;
            else: 
                $param[ 0 ] = trim( $parts[ 2 ] );
            endif;
            if ( empty( $parts[ 10 ] ) ):
                $param[ 2 ] = '0%';
            else:
                $param[ 2 ] = trim( $parts[ 10 ] );
            endif;
            if ( empty( $parts[ 15 ] ) ):
                $param[ 4 ] = '100%';
            else:
                $param[ 4 ] = trim( $parts[ 15 ] );
            endif;
        elseif( '0' == $parts[ 18 ] ):
            $param[ 0 ] = 'top';
            $param[ 2 ] = '0%';
            $param[ 4 ] = '100%';
        elseif ( '1' == $parts[ 18 ] ): 
            $param[ 0 ] = 'left';
            $param[ 2 ] = '0%';
            $param[ 4 ] = '100%';
        endif;
        if ( isset( $parts[ 9 ] ) && isset( $parts[ 14 ] ) ):
            $param[ 1 ] = $parts[ 9 ];
            $param[ 3 ] = $parts[ 14 ];
            ksort( $param );
            return implode( ':', $param );
        else:
            return $value;
        endif;
    }

    /**
     * decode_border
     * De-normalize CTC border syntax into individual properties.
     */
    function decode_border( $value ) {
        $parts = preg_split( '#\s+#', $value, 3 );
        if ( 1 == count( $parts ) ):
            $parts[ 0 ] = $value;
            $parts[ 1 ] = $parts[ 2 ] = '';
        endif;
        return array(
            'width' => empty( $parts[ 0 ] ) ? '' : $parts[ 0 ],
            'style' => empty( $parts[ 1 ] ) ? '' : $parts[ 1 ],
            'color' => empty( $parts[ 2 ] ) ? '' : $parts[ 2 ],
        );
    }

    /**
     * decode_gradient
     * Decode CTC gradient syntax into individual properties.
     */
    function decode_gradient( $value ) {
        $parts = explode( ':', $value, 5 );
        if ( !preg_match( '#(url|none)#i', $value ) && 5 == count( $parts ) ):        
            return array(
                'origin' => empty( $parts[ 0 ] ) ? '' : $parts[ 0 ],
                'color1' => empty( $parts[ 1 ] ) ? '' : $parts[ 1 ],
                'stop1'  => empty( $parts[ 2 ] ) ? '' : $parts[ 2 ],
                'color2' => empty( $parts[ 3 ] ) ? '' : $parts[ 3 ],
                'stop2'  => empty( $parts[ 4 ] ) ? '' : $parts[ 4 ],
            );
        endif;
        return FALSE;
    }

    /**
     * denorm_rule_val
     * Return array of unique values corresponding to specific rule
     * FIXME: only return child if no original value exists
     */    
    function denorm_rule_val( $ruleid ) {
        $this->load_config( 'dict_val' );
        $this->load_config( 'val_ndx' );
        $rule_sel_arr = array();
        foreach ( $this->val_ndx as $qsid => $p ):
            if ( $valarr = $this->unpack_val_ndx( $qsid ) ):
                if ( !isset( $valarr[ $ruleid ] ) ) continue;
                foreach ( array( 'p', 'c' ) as $template ):
                    if ( isset( $valarr[ $ruleid ][ $template ] ) ):
                        foreach ( $valarr[ $ruleid ][ $template ] as $rulevalarr ):
                            $rule_sel_arr[ $rulevalarr[ 0 ] ] = $this->get_dict_value( 'val', $rulevalarr[ 0 ] );
                        endforeach;
                    endif;
                endforeach;
            endif;
        endforeach;
        return $rule_sel_arr;
    }

    /**
     * denorm_val_query
     * Return array of queries, selectors, rules, and values corresponding to
     * specific rule/value combo grouped by query, selector
     * FIXME: only return new values corresponding to specific rulevalid of matching original value
     */    
    function denorm_val_query( $valid, $rule ) {
        $this->load_config( 'dict_rule' );
        $this->load_config( 'val_ndx' );
        $value_query_arr = array();
        if ( $thisruleid = $this->get_dict_id( 'rule', $rule ) ):
            foreach ( $this->val_ndx as $qsid => $p ):
                if ( $valarr = $this->unpack_val_ndx( $qsid ) ):
                    foreach ( $valarr as $ruleid => $values ):
                        if ( $ruleid != $thisruleid ) continue;
                        foreach ( array( 'p', 'c' ) as $template ):
                            if ( isset( $values[ $template ] ) ):
                                foreach ( $values[ $template ] as $rulevalarr ):
                                    if ( $rulevalarr[ 0 ] != $valid ) continue;
                                    $selarr = $this->denorm_query_sel( $qsid );
                                    $value_query_arr[ $rule ][ $selarr[ 'query' ] ][ $qsid ] = $this->denorm_sel_val( $qsid );
                                endforeach;
                            endif;
                        endforeach;
                    endforeach;
                endif;
            endforeach;
        endif;
        return $value_query_arr;
    }

    /**
     * denorm_query_sel
     * Return id, query and selector values of a specific qsid (query-selector ID)
     */    
    function denorm_query_sel( $qsid ) {
        $this->load_config( 'dict_query' );
        $this->load_config( 'dict_sel' );
        $this->load_config( 'dict_seq' );
        $this->load_config( 'dict_qs' );
        $this->load_config( 'dict_token' );
        if ( FALSE === ( $qs = $this->get_dict_value( 'qs', $qsid ) ) ):
            $this->ctc()->debug( $qsid . ' does not exist', __FUNCTION__, __CLASS__ );
            return array();
        endif;
        list( $q, $s ) = explode( ':', $qs );
        if ( $seq = $this->get_dict_value( 'seq', $qsid ) ):
            $this->ctc()->debug( 'get seq: custom: ' . $seq, __FUNCTION__, __CLASS__ );
        else:
            $seq = $qsid;
            $this->ctc()->debug( 'get seq: using qsid: ' . $qsid, __FUNCTION__, __CLASS__ );
        endif;
        $qselarr = array(
            'id'        => $qsid,
            'query'     => $this->get_dict_value( 'query', $q ),
            'selector'  => $this->detokenize( $this->get_dict_value( 'sel', $s ) ),
            'seq'       => $seq,
        );
        return $qselarr;
    }

    /**
     * denorm_sel_val
     * Return array of rules, and values matching specific qsid (query-selector ID)
     * grouped by query, selector
     */    
    function denorm_sel_val( $qsid ) {
        $this->load_config( 'dict_val' );
        $this->load_config( 'dict_rule' );
        $this->load_config( 'val_ndx' );
        $selarr = $this->denorm_query_sel( $qsid );
        if ( $valarr = $this->unpack_val_ndx( $qsid ) ):
            //$this->ctc()->debug( 'valarr: ' . print_r( $valarr, TRUE ), __FUNCTION__, __CLASS__ );
            foreach ( $valarr as $ruleid => $values ):
                //$this->ctc()->debug( 'ruleid: ' . $ruleid, __FUNCTION__, __CLASS__ );
                foreach ( array( 'p', 'c' ) as $template ):
                    $t = 'c' == $template ? 'child' : 'parnt';
                    //$this->ctc()->debug( 'template: ' . $t, __FUNCTION__, __CLASS__ );
                    if ( isset( $values[ $template ] ) ):
                        foreach ( $values[ $template ] as $rulevalarr ):
                            $selarr[ 'value' ][ $this->get_dict_value( 'rule', $ruleid ) ][ $t ][] = array(
                                $this->get_dict_value( 'val', $rulevalarr[ 0 ] ),
                                $rulevalarr[ 1 ],
                                isset( $rulevalarr[ 2 ] ) ? $rulevalarr[ 2 ] : 1,
                            );
                        endforeach;
                    endif;
                endforeach;
            endforeach;
        endif;
        //$this->ctc()->debug( print_r( $selarr, TRUE ), __FUNCTION__, __CLASS__ );
        return $selarr;
    }

    /**
    /**
     * v1.7.5
     * convert and/or normalize rule/value index 
     * to support multiple values per property ( rule )
     * allows backward compatility with < v1.7.5
     */
    function convert_ruleval_array( &$arr ) {
        //$this->ctc()->debug( 'original array: ' . print_r( $arr, TRUE ), __FUNCTION__, __CLASS__ );
        foreach ( array( 'parnt', 'child' ) as $template ):
            // skip if empty array
            if ( !isset( $arr[ $template ] ) ) continue;
            $t = 'child' == $template ? 'c' : 'p';
            // check if using original data structure ( value is scalar )
            if ( ! is_array( $arr[ $template ] ) ):
                /**
                 * create new array to replace old scalar value
                 * value structure is
                 * [0] => value
                 * [1] => important
                 * [2] => priority
                 */
                $arr[ $t ] = array( array( $arr[ $template ], $arr[ 'i_' . $template ], 0, 1 ) );
            else:
                $arr[ $t ] = $arr[ $template ];        
            endif;
            unset( $arr[ $template ] );
        endforeach;
        //$this->ctc()->debug( 'first pass: ' . print_r( $arr, TRUE ), __FUNCTION__, __CLASS__ );
        foreach ( array( 'p', 'c' ) as $template ):
            if ( !isset( $arr[ $template ] ) ) continue;
            $newarr = array();
            // iterate each value and enforce array structure
            foreach ( $arr[ $template ] as $rulevalid => $rulevalarr ):
                // skip if empty array
                if ( empty ( $rulevalarr ) ) continue;
                // 
                if ( ! is_array( $rulevalarr ) ):
                    // important flag moves to individual value in array
                    $important = isset( $arr[ 'i_' . $template ] ) ? $arr[ 'i_' . $template ] : 0;
                    unset( $arr[ 'i_' . $template ] ); 
                    $val = (int) $rulevalarr;
                    $rulevalarr = array( $val, $important, $rulevalid );
                elseif ( !isset( $rulevalarr[ 2 ] ) ):
                    $rulevalarr[ 2 ] = $rulevalid;
                endif;
                $newarr[] = $rulevalarr;
            endforeach;
            $arr[ $template ] = $newarr;
        endforeach;
        //$this->ctc()->debug( 'second pass: ' . print_r( $arr, TRUE ), __FUNCTION__, __CLASS__ );
    }
    
    /**
     * Convert all internal data dictionaries to latest format.
     */
    function convert_dict_arrays(){
        $this->ctc()->debug( 'converting dictionaries from old format', __FUNCTION__, __CLASS__ );
        foreach ( $this->dicts as $dict => $loaded ):
            $this->load_config( $dict );
            switch ( $dict ):
                case 'dict_seq':
                case 'dict_token':
                    break;
                case 'sel_ndx':
                    $this->{ $dict } = array();
                    break;
                case 'val_ndx':
                    foreach ( $this->val_ndx as $qsid => $rulearr ):
                        foreach ( $rulearr as $ruleid => $valarr )
                            $this->convert_ruleval_array( $this->val_ndx[ $qsid ][ $ruleid ] );
                        $this->pack_val_ndx( $qsid, $this->val_ndx[ $qsid ] );
                    endforeach;
                    break;
                case 'dict_qs':
                    $qsarr = array();
                    foreach ( $this->dict_qs as $qsid => $arr ):
                        $qs = $arr[ 'q' ] . ':' . $arr[ 's' ];
                        $qsarr[ $qsid ] = $qs;
                    endforeach;
                    $this->dict_qs = $qsarr;
                    break;
                default:
                    $this->{ $dict } = array_flip( $this->{ $dict } );
                    foreach ( $this->{ $dict } as $key => $val ):
                        if ( 'dict_sel' == $dict )
                            $this->dict_sel[ $key ] = $this->tokenize( (string) $val );
                        else
                            $this->{ $dict }[ $key ] = ( string ) $val;
                    endforeach;
            endswitch;
            //echo '<pre><code><small><strong>' . $dict . '</strong>' . print_r( $this->{ $dict }, TRUE) . '</small></code></pre>' . LF;
        endforeach;
        $this->save_config();
    }
    
    /**
     * denorm_dict_qs
     * Return denormalized array containing query and selector heirarchy
     */    
    function denorm_dict_qs( $query = NULL, $norm = TRUE ) {
        $this->load_config( 'dict_query' );
        $this->load_config( 'dict_sel' );
        $this->load_config( 'dict_token' );
        $this->load_config( 'dict_qs' );
        $retarray = array();
        if ( $query ):
            $q = $this->get_dict_id( 'query', $query );
            $selarr = preg_grep( '/^' . $q . ':/', $this->dict_qs );
            foreach ( $selarr as $qsid => $qs ):
                list( $q, $s ) = explode( ':', $qs );
                if ( $norm )
                    $retarray[ $qsid ] = $this->detokenize( $this->get_dict_value( 'sel', $s ) );
                else
                    $retarray[ $s ] = $qsid;
            endforeach;
        else:
            return array_values( $this->dict_query );
        endif;
        if ( $norm )
            return $this->sort_selectors( $retarray );
        return $retarray;
    }
    
    /**
     * is_important
     * Strip important flag from value reference and return boolean
     * Updating two values at once
     */
    function is_important( &$value ) {
        $important = 0;
        $value = trim( str_ireplace( '!important', '', $value, $important ) );
        return $important;
    }
    
    /**
     * sort_queries
     * De-normalize query data and return array sorted as follows:
     * base
     * @media max-width queries in descending order
     * other @media queries in no particular order
     * @media min-width queries in ascending order
     */
    function sort_queries() {
        $this->load_config( 'dict_query' );
        $queries = array();
        foreach ( $this->dict_query as $queryid => $query ):
            /** lookup **/
            if ( 'base' == $query ):
                $queries[ 'base' ] = -999999;
                continue;
            endif;
            if ( preg_match( "/((min|max)(\-device)?\-width)\s*:\s*(\d+)/", $query, $matches ) ):
                $queries[ $query ] = 'min-width' == $matches[ 1 ] ? $matches[ 4 ] : -$matches[ 4 ];
            else:
                $queries[ $query ] = $queryid - 10000;
            endif;
        endforeach;
        asort( $queries );
        return $queries;
    }
    
    function sort_selectors( $selarr ) {
        $selarr = ( array ) $selarr;
        uasort( $selarr, array( $this, 'cmp_sel' ) );
        return array_flip( $selarr );
    }
    
    function cmp_sel( $a, $b ) {
        $cmpa = preg_replace( "/\W/", '', $a );
        $cmpb = preg_replace( "/\W/", '', $b );
        if ( $cmpa == $cmpb ) return 0;
        return ( $cmpa < $cmpb ) ? -1 : 1;
    }
    
    // sort selectors based on dict_seq if exists, otherwise qsid
    function cmp_seq( $a, $b ) {
        if ( FALSE === ( $cmpa = $this->get_dict_value( 'seq', $a ) ) )
            $cmpa = $a;
        if ( FALSE === ( $cmpb = $this->get_dict_value( 'seq', $b ) ) )
            $cmpb = $b;
        if ( $cmpa == $cmpb ) return 0;
        return ( $cmpa < $cmpb ) ? -1 : 1;
    }

    /**
     * obj_to_utf8
     * sets object data to UTF8
     * flattens to array
     * and stringifies NULLs
     */
    function obj_to_utf8( $data ) {
        if ( is_object( $data ) )
            $data = get_object_vars( $data );
        if ( is_array( $data ) )
            return array_map( array( &$this, __FUNCTION__ ), $data );
        else
            return is_null( $data ) ? '' : utf8_encode( $data );
    }
    
    // convert ascii character into decimal value 
    function to_ascii( $matches ) {
        return ord( $matches[ 0 ] );
    }
    
    // convert decimal value into ascii character
    function from_ascii( $matches ) {
        return chr( $matches[ 0 ] );
    }
    
    /**
     * is_file_ok
     * verify file exists and is in valid location
     * must be in theme or plugin folders
     */
    function is_file_ok( $stylesheet, $permission = 'read' ) {
        // remove any ../ manipulations
        $stylesheet = $this->ctc()->normalize_path( preg_replace( "%\.\./%", '/', $stylesheet ) );
        //$this->ctc()->debug( 'checking file: ' . $stylesheet, __FUNCTION__, __CLASS__ );
        if ( 'read' == $permission && !is_file( $stylesheet ) ):
            $this->ctc()->debug( 'read ' . $stylesheet . ' no file!', __FUNCTION__, __CLASS__ );
            return FALSE;
        elseif ( 'write' == $permission && !is_dir( dirname( $stylesheet ) ) ):
            $this->ctc()->debug( 'write ' . $stylesheet . ' no dir!', __FUNCTION__, __CLASS__ );
            return FALSE;
        elseif ( 'search' == $permission && !is_dir( $stylesheet ) ):
            $this->ctc()->debug( 'search ' . $stylesheet . ' no dir!', __FUNCTION__, __CLASS__ );
            return FALSE;
        endif;
        // check if in themes dir;
        $regex = '%^' . preg_quote( $this->ctc()->normalize_path( get_theme_root() ) ) . '%';
        //$this->ctc()->debug( 'theme regex: ' . $regex, __FUNCTION__, __CLASS__ );
        if ( preg_match( $regex, $stylesheet ) ): 
            //$this->ctc()->debug( $stylesheet . ' ok!', __FUNCTION__, __CLASS__ );
            return $stylesheet;
        endif;
        // check if in plugins dir
        $regex = '%^' . preg_quote( $this->ctc()->normalize_path( WP_PLUGIN_DIR ) ) . '%';
        //$this->ctc()->debug( 'plugin regex: ' . $regex, __FUNCTION__, __CLASS__ );
        if ( preg_match( $regex, $stylesheet ) ):
            //$this->ctc()->debug( $stylesheet . ' ok!', __FUNCTION__, __CLASS__ );
            return $stylesheet;
        endif;
        $this->ctc()->debug( $stylesheet . ' is not in wp folders!', __FUNCTION__, __CLASS__ );
        return FALSE;
    }
    
    /**
     * normalize_color
     * Sets hex string to lowercase and shortens to 3 char format if possible
     */
    function normalize_color( $value ) {
        $value = preg_replace_callback( "/#([0-9A-F]{3}([0-9A-F]{3})?)/i", array( $this, 'tolower' ), $value );
        $value = preg_replace( "/#([0-9A-F])\\1([0-9A-F])\\2([0-9A-F])\\3/i", "#$1$2$3", $value );
        return $value;
    }
    
    function normalize_query( $value ) {
        // space after :
        $value = str_replace( ':', ': ', trim( $value ) );
        // remove multiple whitespace
        $value = preg_replace( "/\s+/s", ' ', $value );
        // remove space after (
        $value = str_replace( '( ', '(', $value );
        // remove space before )
        $value = str_replace( ' )', ')', $value );
        return $value;
    }
    
    // callback for normalize_color regex
    function tolower( $matches ) {
        return '#' . strtolower( $matches[ 1 ] );
    }
    
    function tokenize( $value ){
        return $value;
        // swap out commas and/or consecutive alphas with leading non-alpha if present
        $value = preg_replace_callback( "/(, |[_\W]?[^\W_]+)/", array( $this, 'get_token' ), $value );
        // trim off leading/trailing delimiter
        $value = preg_replace( "/^%%|%%$/", '', $value );
        // split into packable array
        $array = array_map( array( $this, 'to_int' ), preg_split( "/(%%)+/", $value ) );
        //echo '<pre><code><small>';
        //var_dump( $array );
        //echo '</small></code></pre>';
        try {
            return $this->packer->encode( $this->packer->pack( $array ) );
        } catch ( Exception $e ) {
            $this->ctc()->debug( 'Pack failed -- ' . $e->getMessage(), __FUNCTION__, __CLASS__ );
        }
    }
    
    function to_int( $val ){
        return intval( $val ) == $val ? (int) $val : $val;
    }
    
    function detokenize( $packed ){
        return $packed;
        // unpack array
        try {
            $this->packer->reset( $this->packer->decode( $packed ) );
            $array = $this->packer->unpack();
        } catch ( Exception $e ) {
            $this->ctc()->debug( 'Unpack failed -- ' . $e->getMessage(), __FUNCTION__, __CLASS__ );
            return FALSE;
        }
        $unpacked = array();
        // iterate array and replace tokens
        do {
            $token = array_shift( $array );
            if ( 'integer' == gettype( $token ) )
                $unpacked[] = $this->get_dict_value( 'token', $token );
            else
                $unpacked[] = $token;
        } while( $array );
            
        // assemble array
        return implode( '', $unpacked );
    }
    
    function get_token( $matches ){
        $token = $matches[ 1 ];
        $id = $this->get_dict_id( 'token', $token );
        $this->instances[ $id ] = isset( $this->instances[ $id ] ) 
            ? $this->instances[ $id ] + 1 
            : 1;
        return '%%' . $id . '%%';
    }
}